Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Quarta parte del tutorial sul flusso di lavoro di sottoscrizione: implementazione del poller dei task di attività
<a name="swf-sns-tutorial-implementing-activities-poller"></a>

In Amazon SWF, le attività per l'esecuzione di un flusso di lavoro in esecuzione vengono visualizzate nell'*elenco delle attività*, fornito quando si pianifica un'attività nel flusso di lavoro.

Implementeremo un poller di attività di base per gestire queste attività per il nostro flusso di lavoro e lo utilizzeremo per avviare le nostre attività quando Amazon SWF inserisce un'attività nell'elenco delle attività per avviare l'attività.

Per prima cosa, crea un nuovo file denominato `swf_sns_activities.rb`, Utilizzeremo questo file per le seguenti operazioni:
+ Creare un'istanza della classi di attività che abbiamo generato.
+ Registra ogni attività con Amazon SWF.
+ Eseguire il polling delle attività e chiamare `do_activity` per ogni attività quando il relativo nome è visualizzato nell'elenco di task di attività.

In `swf_sns_activities.rb`, aggiungi le istruzioni seguenti per richiedere ognuna delle classi di attività definite.

```
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'
```

A questo punto, creeremo la classe e forniremo codice di inizializzazione.

```
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
```

Oltre a salvare il *dominio* e l'*elenco di task* passati, questo codice crea un'istanza di ogni classe di attività creata. Poiché ogni classe registra l'attività associata (consulta `basic_activity.rb` se hai bisogno di rivedere il codice), questo è sufficiente per far conoscere ad Amazon SWF tutte le attività che eseguiremo.

Ogni attività per le quale viene creata un'istanza è archiviata in una mappa utilizzando il nome dell'attività (ad esempio `get_contact_activity`) come chiave. In questo modo, potremo cercare facilmente le attività nel codice del poller delle attività, che definiremo in seguito.

Crea un nuovo metodo denominato `poll_for_activities` e chiama [poll](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTaskCollection.html#poll-instance_method) su [activity\_tasks](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/Domain.html#activity_tasks-instance_method) mantenuti dal dominio per ottenere task di attività.

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

Possiamo ottenere il nome di attività dal membro [activity\_type](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTask.html#activity_type-instance_method) del task. In seguito, utilizzeremo il nome di attività associato a questo task per cercare la classe su cui eseguire `do_activity`, passandolo al task (che include tutti i dati di input da trasferire all'attività).

```
      # 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
```

Il codice attende il completamento di `do_activity` e quindi chiama [complete\!](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTask.html#complete!-instance_method) o [fail\!](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/SimpleWorkflow/ActivityTask.html#fail!-instance_method) sul task in funzione del codice restituito.

**Nota**  
Questo codice esce dal poller una volta avviata l'attività finale, perché ha completato la sua missione e ha avviato tutte le attività. Nel tuo codice Amazon SWF, se le tue attività potrebbero essere eseguite nuovamente, potresti voler mantenere attivo il poller delle attività a tempo indeterminato.

Questa è la fine del codice per la nostra **ActivitiesPoller**classe, ma aggiungeremo altro codice alla fine del file per consentire all'utente di eseguirlo dalla riga di comando.

```
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
```

Se l'utente esegue il file dalla riga di comando (passandogli un elenco di task di attività come primo argomento), questo codice creerà un'istanza della classe del poller e avvierà il polling delle attività. Al termine dell'esecuzione del poller (dopo l'avvio dell'attività finale), dobbiamo soltanto stampare un messaggio e uscire.

Questo è tutto per il poller delle attività. Non ti resta che eseguire il codice e verificarne il funzionamento, come descritto in [Tutorial sul flusso di lavoro di sottoscrizione: esecuzione del flusso di lavoro](swf-sns-tutorial-running-the-workflow.md).