Creazione di un'Amazon SWFapplicazione semplice

Iniziare un nuovo progetto con Maven.

mvn archetype:generate -DartifactId=helloswf \
-DgroupId=aws.example.helloswf -DinteractiveMode=false

Questo creerà un nuovo progetto con una struttura di progetto Maven standard:

helloswf
├── pom.xml
└── src
    ├── main
    │   └── java
    │       └── aws
    │           └── example
    │               └── helloswf
    │                   └── App.java
    └── test
        └── ...

Puoi ignorare o eliminare la test cartella e tutto ciò che contiene, non la useremo per questo tutorial. Puoi anche eliminareApp.java, poiché lo sostituiremo con nuove classi.

Modifica il pom.xml file del progetto e aggiungi il aws-java-sdk-simpleworkflowmodulo aggiungendo una dipendenza all'interno del <dependencies> blocco.

<dependencies>
  <dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-simpleworkflow</artifactId>
    <version>1.11.1000</version>
  </dependency>
</dependencies>

Assicurati che Maven crei il tuo progetto con il supporto per JDK 1.7+. Aggiungi quanto segue al tuo progetto (prima o dopo il <dependencies> blocco) inpom.xml:

<build>
  <plugins>
    <plugin>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.6.1</version>
      <configuration>
          <source>1.8</source>
          <target>1.8</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Crea il file nella src/main/java/aws/example/helloswf/ directory del progetto.

Aggiungi una package dichiarazione all'inizio di ogni file per dichiararne lo spazio dei nomi. Il progetto di esempio utilizza:

package aws.example.helloswf;

Aggiungi import dichiarazioni per la AmazonSimpleWorkflowClientclasse e per più classi nel com.amazonaws.services.simpleworkflow.model namespace. Per semplificare le cose, useremo:

import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;

Apri il tuo editor di testo e crea il fileHelloTypes.java, aggiungi una dichiarazione di pacchetto e importa secondo i passaggi più comuni.

Dichiara la HelloTypes classe e forniscile i valori da utilizzare per le attività registrate e i tipi di flusso di lavoro:

    public static final String DOMAIN = "HelloDomain";
    public static final String TASKLIST = "HelloTasklist";
    public static final String WORKFLOW = "HelloWorkflow";
    public static final String WORKFLOW_VERSION = "1.0";
    public static final String ACTIVITY = "HelloActivity";
    public static final String ACTIVITY_VERSION = "1.0";

Questi valori verranno utilizzati in tutto il codice.

Dopo le dichiarazioni String, create un'istanza della AmazonSimpleWorkflowClientclasse. Questa è l'interfaccia di base per i Amazon SWF metodi forniti daAWS SDK for Java.

private static final AmazonSimpleWorkflow swf =
    AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();

Lo snippet precedente presuppone che le credenziali temporanee siano associate al profilo. default Se usi un profilo diverso, modifica il codice precedente come segue e sostituisci profile_name con il nome del nome effettivo del profilo.

private static final AmazonSimpleWorkflow swf =
        AmazonSimpleWorkflowClientBuilder
                .standard()
                .withCredentials(new ProfileCredentialsProvider("profile_name"))
                .withRegion(Regions.DEFAULT_REGION)
                .build();

Aggiungete una nuova funzione per registrare un dominio SWF. Un dominio è un contenitore logico per una serie di attività SWF e tipi di flussi di lavoro correlati. I componenti SWF possono comunicare tra loro solo se esistono all'interno dello stesso dominio.

    try {
        System.out.println("** Registering the domain '" + DOMAIN + "'.");
        swf.registerDomain(new RegisterDomainRequest()
            .withName(DOMAIN)
            .withWorkflowExecutionRetentionPeriodInDays("1"));
    } catch (DomainAlreadyExistsException e) {
        System.out.println("** Domain already exists!");
    }

Quando registri un dominio, gli fornisci un nome (qualsiasi set da 1 a 256 caratteri esclusi:,, /|, i caratteri di controllo o la stringa letterale '`arn') e un periodo di conservazione, che è il numero di giorni in cui Amazon SWF verranno conservati i dati della cronologia di esecuzione del flusso di lavoro dopo il completamento dell'esecuzione di un flusso di lavoro. Il periodo massimo di conservazione dell'esecuzione del flusso di lavoro massimo è di 90 giorni. RegisterDomainRequestPer ulteriori informazioni, consulta.

Se esiste già un dominio con quel nome, DomainAlreadyExistsExceptionviene generato un. Poiché non ci interessa se il dominio è già stato creato, possiamo ignorare l'eccezione.

Aggiungi una funzione per registrare un nuovo tipo di attività. Un'attività rappresenta un'unità di lavoro nel flusso di lavoro.

    try {
        System.out.println("** Registering the activity type '" + ACTIVITY +
            "-" + ACTIVITY_VERSION + "'.");
        swf.registerActivityType(new RegisterActivityTypeRequest()
            .withDomain(DOMAIN)
            .withName(ACTIVITY)
            .withVersion(ACTIVITY_VERSION)
            .withDefaultTaskList(new TaskList().withName(TASKLIST))
            .withDefaultTaskScheduleToStartTimeout("30")
            .withDefaultTaskStartToCloseTimeout("600")
            .withDefaultTaskScheduleToCloseTimeout("630")
            .withDefaultTaskHeartbeatTimeout("10"));
    } catch (TypeAlreadyExistsException e) {
        System.out.println("** Activity type already exists!");
    }

Un tipo di attività è identificato da un nome e da una versione, che vengono utilizzati per identificare in modo univoco l'attività rispetto a qualsiasi altra nel dominio in cui è registrata. Le attività contengono anche una serie di parametri opzionali, come l'elenco delle attività predefinito utilizzato per ricevere attività e dati da SWF e una serie di timeout diversi che è possibile utilizzare per porre vincoli sulla durata delle diverse parti dell'esecuzione dell'attività. RegisterActivityTypeRequestPer ulteriori informazioni, consulta.

Apri il tuo editor di testo e crea il fileActivityWorker.java, aggiungi una dichiarazione di pacchetto e importa secondo i passaggi più comuni.

import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;

Aggiungi la ActivityWorker classe al file e assegnagli un membro dei dati per contenere un client SWF con Amazon SWF cui interagire:

    private static final AmazonSimpleWorkflow swf =
            AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();

Aggiungi il metodo che useremo come attività:

private static String sayHello(String input) throws Throwable {
    return "Hello, " + input + "!";
}

L'attività prende semplicemente una stringa, la combina in un saluto e restituisce il risultato. Sebbene ci siano poche possibilità che questa attività generi un'eccezione, è consigliabile progettare attività che possano generare un errore se qualcosa va storto.

Aggiungi un main metodo che useremo come metodo di polling delle attività. Inizieremo aggiungendo del codice per sondare l'elenco delle attività relative alle attività:

        System.out.println("Polling for an activity task from the tasklist '"
                + HelloTypes.TASKLIST + "' in the domain '" +
                HelloTypes.DOMAIN + "'.");

        ActivityTask task = swf.pollForActivityTask(
            new PollForActivityTaskRequest()
                .withDomain(HelloTypes.DOMAIN)
                .withTaskList(
                    new TaskList().withName(HelloTypes.TASKLIST)));

        String task_token = task.getTaskToken();

L'attività riceve le attività Amazon SWF richiamando il pollForActivityTask metodo del client SWF, specificando il dominio e l'elenco delle attività da utilizzare nel passaggio. PollForActivityTaskRequest

Una volta ricevuta un'attività, ne riceviamo un identificatore univoco chiamando il metodo dell'getTaskTokenattività.

Quindi, scrivi del codice per elaborare le attività che arrivano. Aggiungi quanto segue al tuo main metodo, subito dopo il codice che esegue il sondaggio per l'attività e ne recupera il token.

    if (task_token != null) {
        String result = null;
        Throwable error = null;

        try {
            System.out.println("Executing the activity task with input '" +
                    task.getInput() + "'.");
            result = sayHello(task.getInput());
        } catch (Throwable th) {
            error = th;
        }

        if (error == null) {
            System.out.println("The activity task succeeded with result '"
                    + result + "'.");
            swf.respondActivityTaskCompleted(
                new RespondActivityTaskCompletedRequest()
                    .withTaskToken(task_token)
                    .withResult(result));
        } else {
            System.out.println("The activity task failed with the error '"
                    + error.getClass().getSimpleName() + "'.");
            swf.respondActivityTaskFailed(
                new RespondActivityTaskFailedRequest()
                    .withTaskToken(task_token)
                    .withReason(error.getClass().getSimpleName())
                    .withDetails(error.getMessage()));
        }
    }

Se il task token non lo ènull, possiamo iniziare a eseguire il metodo activity (sayHello), fornendogli i dati di input inviati con l'attività.

Se l'operazione è riuscita (non è stato generato alcun errore), il worker risponde a SWF chiamando il respondActivityTaskCompleted metodo del client SWF con un RespondActivityTaskCompletedRequestoggetto contenente il token dell'attività e i dati dei risultati dell'attività.

D'altra parte, se l'attività non è riuscita, rispondiamo chiamando il respondActivityTaskFailed metodo con un RespondActivityTaskFailedRequestoggetto, passandogli il token dell'attività e le informazioni sull'errore.

Apri il tuo editor di testo e crea il fileWorkflowWorker.java, aggiungi una dichiarazione di pacchetto e importa secondo i passaggi più comuni.

Aggiungi alcune importazioni aggiuntive al file:

import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

Dichiarate la WorkflowWorker classe e create un'istanza della AmazonSimpleWorkflowClientclasse utilizzata per accedere ai metodi SWF.

    private static final AmazonSimpleWorkflow swf =
            AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();

Aggiungi il main metodo. Il metodo si ripete continuamente, esaminando le attività decisionali utilizzando il metodo del client SWF. pollForDecisionTask PollForDecisionTaskRequestFornisce i dettagli.

    PollForDecisionTaskRequest task_request =
        new PollForDecisionTaskRequest()
            .withDomain(HelloTypes.DOMAIN)
            .withTaskList(new TaskList().withName(HelloTypes.TASKLIST));

    while (true) {
        System.out.println(
                "Polling for a decision task from the tasklist '" +
                HelloTypes.TASKLIST + "' in the domain '" +
                HelloTypes.DOMAIN + "'.");

        DecisionTask task = swf.pollForDecisionTask(task_request);

        String taskToken = task.getTaskToken();
        if (taskToken != null) {
            try {
                executeDecisionTask(taskToken, task.getEvents());
            } catch (Throwable th) {
                th.printStackTrace();
            }
        }
    }

Una volta ricevuta un'attività, chiamiamo il suo getTaskToken metodo, che restituisce una stringa che può essere utilizzata per identificare l'attività. Se il token restituito non lo ènull, lo elaboriamo ulteriormente nel executeDecisionTask metodo, passandogli il task token e l'elenco degli HistoryEventoggetti inviati con l'attività.

Aggiungi il executeDecisionTask metodo, prendendo il task token (aString) e l'HistoryEventelenco.

    List<Decision> decisions = new ArrayList<Decision>();
    String workflow_input = null;
    int scheduled_activities = 0;
    int open_activities = 0;
    boolean activity_completed = false;
    String result = null;

Abbiamo anche impostato alcuni membri dei dati per tenere traccia di cose come:

Quindi, aggiungi del codice executeDecisionTask per elaborare gli HistoryEvent oggetti inviati con l'attività, in base al tipo di evento riportato dal getEventType metodo.

System.out.println("Executing the decision task for the history events: [");
for (HistoryEvent event : events) {
    System.out.println("  " + event);
    switch(event.getEventType()) {
        case "WorkflowExecutionStarted":
            workflow_input =
                event.getWorkflowExecutionStartedEventAttributes()
                     .getInput();
            break;
        case "ActivityTaskScheduled":
            scheduled_activities++;
            break;
        case "ScheduleActivityTaskFailed":
            scheduled_activities--;
            break;
        case "ActivityTaskStarted":
            scheduled_activities--;
            open_activities++;
            break;
        case "ActivityTaskCompleted":
            open_activities--;
            activity_completed = true;
            result = event.getActivityTaskCompletedEventAttributes()
                          .getResult();
            break;
        case "ActivityTaskFailed":
            open_activities--;
            break;
        case "ActivityTaskTimedOut":
            open_activities--;
            break;
    }
}
System.out.println("]");

Ai fini del nostro flusso di lavoro, siamo molto interessati a:

Gli altri tipi di eventi possono essere utilizzati se il flusso di lavoro li richiede. Vedi la descrizione della HistoryEventclasse per informazioni su ogni tipo di evento.

+ NOTA: le stringhe nelle switch istruzioni sono state introdotte in Java 7. Se stai usando una versione precedente di Java, puoi utilizzare la EventTypeclasse per convertire il valore String restituito history_event.getType() da in un valore enum e poi di nuovo in un, String se necessario:

Dopo la switch dichiarazione, aggiungi altro codice per rispondere con una decisione appropriata in base all'attività ricevuta.

if (activity_completed) {
    decisions.add(
        new Decision()
            .withDecisionType(DecisionType.CompleteWorkflowExecution)
            .withCompleteWorkflowExecutionDecisionAttributes(
                new CompleteWorkflowExecutionDecisionAttributes()
                    .withResult(result)));
} else {
    if (open_activities == 0 && scheduled_activities == 0) {

        ScheduleActivityTaskDecisionAttributes attrs =
            new ScheduleActivityTaskDecisionAttributes()
                .withActivityType(new ActivityType()
                    .withName(HelloTypes.ACTIVITY)
                    .withVersion(HelloTypes.ACTIVITY_VERSION))
                .withActivityId(UUID.randomUUID().toString())
                .withInput(workflow_input);

        decisions.add(
                new Decision()
                    .withDecisionType(DecisionType.ScheduleActivityTask)
                    .withScheduleActivityTaskDecisionAttributes(attrs));
    } else {
        // an instance of HelloActivity is already scheduled or running. Do nothing, another
        // task will be scheduled once the activity completes, fails or times out
    }
}

System.out.println("Exiting the decision task with the decisions " + decisions);

In entrambi i casi, le informazioni sulla decisione vengono aggiunte all'Decisionelenco dichiarato all'inizio del metodo.

Completa l'attività decisionale restituendo l'elenco degli Decision oggetti raccolti durante l'elaborazione dell'attività. Aggiungi questo codice alla fine del executeDecisionTask metodo che abbiamo scritto:

swf.respondDecisionTaskCompleted(
    new RespondDecisionTaskCompletedRequest()
        .withTaskToken(taskToken)
        .withDecisions(decisions));

Il respondDecisionTaskCompleted metodo del client SWF utilizza il token dell'operazione che identifica l'operazione e l'elenco di Decision oggetti.

Apri il tuo editor di testo e crea il fileWorkflowStarter.java, aggiungi una dichiarazione di pacchetto e importa secondo i passaggi più comuni.

Aggiungi la WorkflowStarter classe:

package aws.example.helloswf;


import com.amazonaws.regions.Regions;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflow;
import com.amazonaws.services.simpleworkflow.AmazonSimpleWorkflowClientBuilder;
import com.amazonaws.services.simpleworkflow.model.*;

public class WorkflowStarter {
    private static final AmazonSimpleWorkflow swf =
            AmazonSimpleWorkflowClientBuilder.standard().withRegion(Regions.DEFAULT_REGION).build();
    public static final String WORKFLOW_EXECUTION = "HelloWorldWorkflowExecution";

    public static void main(String[] args) {
        String workflow_input = "{SWF}";
        if (args.length > 0) {
            workflow_input = args[0];
        }

        System.out.println("Starting the workflow execution '" + WORKFLOW_EXECUTION +
                "' with input '" + workflow_input + "'.");

        WorkflowType wf_type = new WorkflowType()
            .withName(HelloTypes.WORKFLOW)
            .withVersion(HelloTypes.WORKFLOW_VERSION);

        Run run = swf.startWorkflowExecution(new StartWorkflowExecutionRequest()
            .withDomain(HelloTypes.DOMAIN)
            .withWorkflowType(wf_type)
            .withWorkflowId(WORKFLOW_EXECUTION)
            .withInput(workflow_input)
            .withExecutionStartToCloseTimeout("90"));

        System.out.println("Workflow execution started with the run id '" +
                run.getRunId() + "'.");
    }
}

La WorkflowStarter classe è costituita da un singolo metodomain, che accetta un argomento opzionale passato alla riga di comando come dati di input per il flusso di lavoro.

Il metodo client SWFstartWorkflowExecution, accetta un StartWorkflowExecutionRequestoggetto come input. Qui, oltre a specificare il dominio e il tipo di flusso di lavoro da eseguire, forniamo:

L'oggetto Run che startWorkflowExecution restituisce fornisce un ID di esecuzione, un valore che può essere utilizzato per identificare l'esecuzione di questo particolare flusso di lavoro nella Amazon SWF cronologia delle esecuzioni del flusso di lavoro.

+ NOTA: l'ID di esecuzione è generato da Amazon SWF e non è uguale al nome di esecuzione del flusso di lavoro che fornisci all'avvio dell'esecuzione del flusso di lavoro.