Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Abonnement-Workflow, Anleitung Teil 4: Implementieren des Pollers für Aktivitätsaufgaben
<a name="swf-sns-tutorial-implementing-activities-poller"></a>

In Amazon SWF werden Aktivitätsaufgaben für eine laufende Workflow-Ausführung in der *Aktivitätsaufgabenliste* angezeigt, die angezeigt wird, wenn Sie eine Aktivität im Workflow planen.

Wir implementieren einen einfachen Aktivitätsabfrage, um diese Aufgaben für unseren Workflow zu erledigen, und verwenden ihn, um unsere Aktivitäten zu starten, wenn Amazon SWF eine Aufgabe auf die Aktivitätsaufgabenliste setzt, um die Aktivität zu starten.

Erstellen Sie zu Beginn eine neue Datei mit dem Namen `swf_sns_activities.rb`. Anhand dieser Datei können Sie folgende Aktivitäten ausführen:
+ Instanziieren der von uns erstellten Aktivitätenklassen.
+ Registrieren Sie jede Aktivität bei Amazon SWF.
+ Abfragen zu Aktivitäten und Aufrufen von `do_activity` für die einzelnen Aktivitäten, wenn deren Name auf der Aktivitätsaufgabenliste erscheint.

Fügen Sie unter `swf_sns_activities.rb` die folgenden Anweisungen hinzu, um die einzelnen Aktivitätsklassen anzufordern, die von uns festgelegt wurden.

```
require_relative 'get_contact_activity.rb'
require_relative 'subscribe_topic_activity.rb'
require_relative 'wait_for_confirmation_activity.rb'
require_relative 'send_result_activity.rb'
```

Jetzt erstellen wir die Klasse und stellen den Initialisierungscode bereit.

```
class ActivitiesPoller

  def initialize(domain, workflowId)
    @domain = domain
    @workflowId = workflowId
    @activities = {}

    # These are the activities we'll run
    activity_list = [
      GetContactActivity,
      SubscribeTopicActivity,
      WaitForConfirmationActivity,
      SendResultActivity ]

    activity_list.each do | activity_class |
      activity_obj = activity_class.new
      puts "** initialized and registered activity: #{activity_obj.name}"
      # add it to the hash
      @activities[activity_obj.name.to_sym] = activity_obj
    end
  end
```

Zusätzlich zum Speichern der vergangenen Aktivitäten in der *Domäne* und *Aufgabenliste*, instanziiert dieser Code alle der von uns erstellten Aktivitätsklassen. Da jede Klasse ihre zugehörige Aktivität registriert (siehe, `basic_activity.rb` falls Sie diesen Code überprüfen müssen), reicht dies aus, um Amazon SWF über alle Aktivitäten zu informieren, die wir ausführen werden.

Jede instanziierte Aktivität wird anhand des Aktivitätsnamens (beispielsweise `get_contact_activity`) als Schlüssel auf einer Map gespeichert, damit sie problemlos im Aktivitäten-Poller-Code, den wir als Nächstes definieren werden, nachgeschlagen werden kann.

Erstellen Sie eine neue Methode mit dem Namen `poll_for_activities` und rufen Sie die Abfrage [https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTaskCollection.html#poll-instance_method](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTaskCollection.html#poll-instance_method) für die auf der Domäne befindlichen [activity\_tasks](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/Domain.html#activity_tasks-instance_method) auf, um die Aktivitätsaufgaben zu erhalten.

```
  def poll_for_activities
    @domain.activity_tasks.poll(@workflowId) do | task |
      activity_name = task.activity_type.name
```

Der Aktivitätsname kann vom [activity\_type](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTask.html#activity_type-instance_method)-Element der Aufgabe abgerufen werden. Als Nächstes verwenden wir den Aktivitätsnamen, der dieser Aufgabe zugeordnet ist, um die Klasse nachzuschlagen, auf der `do_activity` ausgeführt wird, und um die Aufgabe weiterzuleiten (dabei sind auch die Eingabedaten eingeschlossen, die an diese Aktivität weitergeleitet werden sollen).

```
      # find the task on the activities list, and run it.
      if @activities.key?(activity_name.to_sym)
        activity = @activities[activity_name.to_sym]
        puts "** Starting activity task: #{activity_name}"
        if activity.do_activity(task)
          puts "++ Activity task completed: #{activity_name}"
          task.complete!({ :result => activity.results })
          # if this is the final activity, stop polling.
          if activity_name == 'send_result_activity'
             return true
          end
        else
          puts "-- Activity task failed: #{activity_name}"
          task.fail!(
            { :reason => activity.results[:reason],
              :details => activity.results[:detail] } )
        end
      else
        puts "couldn't find key in @activities list: #{activity_name}"
        puts "contents: #{@activities.keys}"
      end
    end
  end
end
```

Der Code wartet darauf, dass `do_activity` abgeschlossen wird und markiert die Aufgabe entweder als [abgeschlossen\!](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTask.html#complete!-instance_method) oder [fehlschlagen\!](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTask.html#fail!-instance_method). Dies ist hängt vom Rückgabecode ab.

**Anmerkung**  
Dieser Code wird aus dem Poller beendet, sobald die letzte Aktivität gestartet wurde, weil er seine Mission erfüllt und alle Aktivitäten gestartet hat. Wenn Ihre Aktivitäten in Ihrem eigenen Amazon SWF SWF-Code erneut ausgeführt werden, sollten Sie den Aktivitätsumfrage möglicherweise auf unbestimmte Zeit laufen lassen.

Das ist das Ende des Codes für unsere **ActivitiesPoller**Klasse, aber wir fügen am Ende der Datei etwas mehr Code hinzu, damit der Benutzer ihn von der Befehlszeile aus ausführen kann.

```
if __FILE__ == $0
  if ARGV.count < 1
    puts "You must supply a task-list name to use!"
    exit
  end
  poller = ActivitiesPoller.new(init_domain, ARGV[0])
  poller.poll_for_activities
  puts "All done!"
end
```

Wenn der Benutzer die Datei von der Befehlszeile aus ausführt (und ihr eine Aktivitätsaufgabenliste als erstes Argument weiterleitet), instanziiert dieser Code die Poller-Klasse und startet diese durch die Abfrage nach Aktivitäten. Nachdem der Poller seine Aufgabe abgeschlossen hat (nach dem Start der letzten Aktivität), drucken wir einfach eine Nachricht aus und beenden ihn.

Das ist alles zum Aktivitäten-Poller. Jetzt müssen Sie nur noch den Code ausführen und in [Abonnement-Workflow, Anleitung: Ausführen des Workflows](swf-sns-tutorial-running-the-workflow.md) sehen, wie er funktioniert.