Création d'une Amazon SWF application simple

Démarrez un nouveau projet avec Maven :

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

Cela permet de créer un nouveau projet avec une structure de projet Maven standard :

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

Vous pouvez ignorer ou supprimer le répertoire test et tout ce qu'il contient, car nous ne l'utiliserons pas pour ce didacticiel. Vous pouvez également supprimer App.java, car nous le remplacerons par de nouvelles classes.

Modifiez le pom.xml fichier du projet et ajoutez le aws-java-sdk-simpleworkflowmodule en ajoutant une dépendance correspondante dans le <dependencies> bloc.

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

Assurez-vous que Maven génère votre projet avec JDK 1.7 ou version ultérieure. Ajoutez les éléments suivants à votre projet (avant ou après le bloc <dependencies>) dans pom.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>

Créez le fichier dans le répertoire src/main/java/aws/example/helloswf/ du projet.

Ajoutez une déclaration package au début de chaque fichier pour déclarer son espace de noms. L'exemple de projet utilise :

package aws.example.helloswf;

Ajoutez import des déclarations pour la AmazonSimpleWorkflowClientclasse et pour plusieurs classes dans l'espace de com.amazonaws.services.simpleworkflow.model nommage. Pour simplifier, nous utilisons :

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

Ouvrez votre éditeur de texte et créez le fichier HelloTypes.java, en ajoutant une déclaration de package et des déclarations d'importation conformément aux étapes courantes.

Déclarez la classe HelloTypes et fournissez-lui des valeurs à utiliser pour vos types d'activité et de flux de travail enregistrés :

    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";

Ces valeurs seront utilisées dans l'ensemble du code.

Après les déclarations String, créez une instance de la AmazonSimpleWorkflowClientclasse. Il s'agit de l'interface de base pour les méthodes Amazon SWF fournies par le kit AWS SDK for Java.

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

L'extrait de code précédent suppose que des informations d'identification temporaires sont associées au default profil. Si vous utilisez un profil différent, modifiez le code ci-dessus comme suit et remplacez profile_name par le nom du profil actuel.

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

Ajoutez une nouvelle fonction pour enregistrer un domaine SWF. Un domaine est un conteneur logique pour différents types d'activité et de flux de travail SWF associés. Les composants SWF ne peuvent communiquer entre eux que s'ils sont situés dans le même domaine.

    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!");
    }

Lorsque vous enregistrez un domaine, vous lui fournissez un nom (un ensemble de 1 à 256 caractères : /|, à l'exclusion des caractères de contrôle ou de la chaîne littérale « arn ») et une période de conservation, qui correspond au nombre de jours pendant lesquels les données d'historique d'exécution de votre flux de travail Amazon SWF seront conservées une fois l'exécution d'un flux de travail terminée. La période de conservation maximale pour les exécutions de flux de travail est de 90 jours. RegisterDomainRequestPour plus d'informations, voir.

Si un domaine portant ce nom existe déjà, un DomainAlreadyExistsExceptionest généré. Comme cela ne pose aucun problème si le domaine a déjà été créé, nous pouvons ignorer cette exception.

Ajoutez une fonction pour enregistrer un nouveau type d'activité. Une activité représente une unité de travail de votre flux de travail.

    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 type d'activité est identifié par un nom et une version, qui sont utilisés pour identifier l'activité de façon unique parmi toutes les autres activités du domaine dans lequel cette activité est enregistrée. Les activités contiennent également différents paramètres facultatifs, comme la liste de tâches par défaut utilisée pour recevoir des tâches et des données provenant de SWF, ainsi que différents délais d'expiration permettant d'appliquer des contraintes quant à la durée de l'exécution de différentes parties de l'activité. RegisterActivityTypeRequestPour plus d'informations, voir.

Ouvrez votre éditeur de texte et créez le fichier ActivityWorker.java, en ajoutant une déclaration de package et des déclarations d'importation conformément aux étapes courantes.

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

Ajoutez la classe ActivityWorker au fichier et fournissez-lui un membre de données pour stocker un client SWF que nous utiliserons pour interagir avec Amazon SWF :

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

Ajoutez la méthode que nous utiliserons comme activité :

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

L'activité prend simplement une chaîne, la combine en une salutation et renvoie le résultat. Même si les risques que cette activité lève une exception sont minimes, il est judicieux de concevoir des activités qui peuvent générer une erreur en cas de problème.

Ajoutez une méthode main que nous utiliserons comme méthode d'interrogation des tâches d'activité. Nous démarrons cette méthode en ajoutant du code pour rechercher des tâches d'activité dans la liste des tâches :

        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'activité reçoit des tâches Amazon SWF en appelant la pollForActivityTask méthode du client SWF, en spécifiant le domaine et la liste de tâches à utiliser dans le fichier transmis PollForActivityTaskRequest.

Une fois qu'une tâche est reçue, nous récupérons un identificateur unique pour celle-ci en appelant la méthode getTaskToken de la tâche.

Ensuite, écrivez du code pour traiter les tâches qui arrivent. Ajoutez ce qui suit à votre méthode main juste après le code qui recherche la tâche et récupère son jeton.

    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()));
        }
    }

Si le jeton de la tâche n'est pas null, nous pouvons commencer à exécuter la méthode d'activité (sayHello) en lui fournissant les données d'entrée qui ont été envoyées avec la tâche.

Si la tâche aboutit (aucune erreur n'a été générée), le travailleur répond au SWF en appelant la respondActivityTaskCompleted méthode du client SWF avec un RespondActivityTaskCompletedRequestobjet contenant le jeton de tâche et les données de résultat de l'activité.

En revanche, si la tâche échoue, nous répondons en appelant la respondActivityTaskFailed méthode avec un RespondActivityTaskFailedRequestobjet, en lui transmettant le jeton de tâche et des informations sur l'erreur.

Ouvrez votre éditeur de texte et créez le fichier WorkflowWorker.java, en ajoutant une déclaration de package et des déclarations d'importation conformément aux étapes courantes.

Ajoutez quelques déclarations d'importation supplémentaires au fichier :

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;

Déclarez la WorkflowWorker classe et créez une instance de la AmazonSimpleWorkflowClientclasse utilisée pour accéder aux méthodes SWF.

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

Ajoutez la méthode main. Cette méthode exécute une boucle continue en recherchant les tâches de décision à l'aide de la méthode pollForDecisionTask du client SWF. Le PollForDecisionTaskRequestfournit les détails.

    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();
            }
        }
    }

Une fois qu'une tâche est reçue, nous appelons sa méthode getTaskToken qui renvoie une chaîne permettant d'identifier la tâche. Si le jeton renvoyé ne l'est pasnull, nous le traitons plus avant dans la executeDecisionTask méthode, en lui transmettant le jeton de tâche et la liste des HistoryEventobjets envoyés avec la tâche.

Ajoutez la méthode executeDecisionTask, en prenant le jeton de la tâche (un élément String) et la liste HistoryEvent.

    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;

Nous configurons également des membres de données pour suivre des éléments comme :

Ajoutez ensuite du code à executeDecisionTask pour traiter les objets HistoryEvent qui ont été envoyés avec la tâche, en fonction du type d'événement signalé par la méthode getEventType.

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("]");

Dans le cadre de notre flux de travail, voici les éléments qui présentent le plus d'intérêt pour nous :

Les autres types d'événement peuvent être utilisés s'ils sont nécessaires pour votre flux de travail. Consultez la description du HistoryEventcours pour plus d'informations sur chaque type d'événement.

+ REMARQUE : Les chaînes dans switch les instructions ont été introduites dans Java 7. Si vous utilisez une version antérieure de Java, vous pouvez utiliser la EventTypeclasse pour convertir la valeur String renvoyée par en une valeur history_event.getType() d'énumération, puis de nouveau en une String si nécessaire :

Après l'instruction switch, ajoutez du code pour répondre avec une décision appropriée en fonction de la tâche qui a été reçue.

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);

Dans les deux cas, les informations de décision sont ajoutées à la liste Decision qui a été déclarée en haut de la méthode.

Terminez la tâche de décision en renvoyant la liste des objets Decision collectés pendant le traitement de la tâche. Ajoutez ce code à la fin de la méthode executeDecisionTask que nous avons écrite :

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

La méthode respondDecisionTaskCompleted du client SWF prend le jeton de tâche qui identifie la tâche, ainsi que la liste d'objets Decision.

Ouvrez votre éditeur de texte et créez le fichier WorkflowStarter.java, en ajoutant une déclaration de package et des déclarations d'importation conformément aux étapes courantes.

Ajoutez la classe WorkflowStarter :

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 classe WorkflowStarter est constituée d'une seule méthode, main, qui prend un argument facultatif transmis dans la ligne de commande en tant que données d'entrée pour le flux de travail.

La méthode client SWFstartWorkflowExecution, prend un StartWorkflowExecutionRequestobjet en entrée. Ici, en plus de spécifier le domaine et le type de flux de travail à exécuter, nous lui fournissons :

L'objet Run renvoyé par startWorkflowExecution fournit un ID d'exécution, c'est-à-dire une valeur qui peut être utilisée pour identifier cette exécution de flux de travail particulière dans l'historique Amazon SWF de vos exécutions de flux de travail.

+ REMARQUE : L'ID d'exécution est généré par Amazon SWF le nom d'exécution du flux de travail que vous transmettez au démarrage de l'exécution du flux de travail et n'est pas le même que celui-ci.