Compilar um aplicativo do Amazon SWF simples

Inicie um novo projeto com o Maven:

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

Isso criará um novo projeto com uma estrutura de projeto maven padrão:

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

É possível ignorar ou excluir o diretório test e tudo o que ele contiver, e não usaremos isso neste tutorial. Também é possível excluir App.java, porque o substituiremos por novas classes.

Edite o arquivo pom.xml do projeto e adicione o módulo aws-java-sdk-simpleworkflow incluindo uma dependência para ele dentro do bloco <dependencies>.

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

Verifique se o Maven compila o projeto com suporte ao JDK 1.7+. Adicione o seguinte ao projeto (antes ou depois do bloco <dependencies>) em 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>

Crie o arquivo no diretório src/main/java/aws/example/helloswf/ do projeto.

Adicione uma declaração package ao início de cada arquivo para declarar o namespace. O projeto de exemplo usa:

package aws.example.helloswf;

Adicione declarações import para a classe AmazonSimpleWorkflowClient e para várias classes no namespace com.amazonaws.services.simpleworkflow.model. Para simplificar, usaremos:

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

Abra o editor de textos e crie o arquivo HelloTypes.java, adicionando uma declaração de pacote e importações de acordo com as etapas comuns.

Declare a classe HelloTypes e atribua a ela valores a serem usados nos tipos de atividade e fluxo de trabalho registrados:

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

Esses valores serão usados em todo o código.

Após as declarações String, crie uma instância da classe AmazonSimpleWorkflowClient. Trata-se da interface básica para os métodos do Amazon SWF fornecidos pelo AWS SDK for Java.

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

O trecho anterior pressupõe que as credenciais temporárias estejam associadas ao perfil default. Se você usar um perfil diferente, modifique o código acima da seguinte forma e substitua profile_name pelo verdadeiro nome do perfil.

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

Adicione uma nova função para registrar um domínio do SWF. Domínio é um contêiner lógico para uma série de tipos de atividade e de fluxo de trabalho do SWF relacionados. Os componentes do SWF só poderão se comunicar entre si se estiverem no mesmo domínio.

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

Ao registrar um domínio, você dá a ele um nome (qualquer conjunto de 1 a 256 caracteres, exceto :, /, |, caracteres de controle ou a string literal “arn”) e um período de retenção, que é o número de dias por que o Amazon SWF manterá os dados do histórico de execução do fluxo de trabalho depois que uma execução do fluxo de trabalho tiver sido concluída. O período de retenção da execução do fluxo de trabalho máximo é 90 dias. Consulte RegisterDomainRequest para obter informações.

Se já houver um domínio com esse nome, um DomainAlreadyExistsException será lançado. Como não estamos preocupados se o domínio já foi criado, podemos ignorar a exceção.

Adicione uma função para registrar um novo tipo de atividade. Uma atividade representa uma unidade de trabalho no fluxo de trabalho.

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

Um tipo de atividade é identificado por um nome e uma versão, usados para identificar com exclusividade a atividade em quaisquer outros no domínio em que esteja registrado. As atividades também contêm alguns parâmetros opcionais, como a task-list padrão usada para receber tarefas e dados do SWF e alguns tempos limite diferentes que podem ser usados por você para impor restrições ao tempo em que partes diferentes da execução da atividade podem demorar. Consulte RegisterActivityTypeRequest para obter mais informações.

Abra o editor de textos e crie o arquivo ActivityWorker.java, adicionando uma declaração de pacote e importações de acordo com as etapas comuns.

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

Adicione a classe ActivityWorker ao arquivo e atribua a ele um membro de dados para manter um cliente do SWF que usaremos para interagir com o Amazon SWF:

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

Adicione o método que usaremos como uma atividade:

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

A atividade simplesmente utiliza uma string, integra a um cumprimento e retorna o resultado. Embora não seja muito provável que essa atividade crie uma exceção, é uma boa ideia criar atividades que possam lançar um erro se algo der errado.

Adicione um método main que usaremos como o método de sondagem da tarefa de atividade. Nós o iniciaremos adicionando alguns códigos para fazer uma sondagem à lista de tarefas para tarefas de atividade:

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

A atividade recebe tarefas do Amazon SWF chamando o método pollForActivityTask do cliente do SWF, especificando o domínio e a lista de tarefas a serem usados no PollForActivityTaskRequest passado.

Assim que uma tarefa for recebida, recuperaremos um identificador exclusivo para ela, chamando o método getTaskToken da tarefa.

Em seguida, escreva um código para processar as tarefas recebidas. Adicione o seguinte ao método main, logo depois do código que faz uma sondagem à tarefa e recupera o token da tarefa.

    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 o token da tarefa não for null, poderemos começar executando o método de atividade (sayHello), fornecendo a ele os dados de entrada enviados com a tarefa.

Se a tarefa for bem-sucedida (sem erro gerado), o operador responderá ao SWF chamando o método respondActivityTaskCompleted do cliente do SWF com um objeto RespondActivityTaskCompletedRequest que contém o token da tarefa e os dados resultantes da atividade.

Por outro lado, se a tarefa tiver falhado, responderemos chamando o método respondActivityTaskFailed com um objeto RespondActivityTaskFailedRequest, passando a ela o token da tarefas e as informações sobre o erro.

Abra o editor de textos e crie o arquivo WorkflowWorker.java, adicionando uma declaração de pacote e importações de acordo com as etapas comuns.

Adicione algumas importações adicionais ao arquivo:

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;

Declare a classe WorkflowWorker e crie uma instância da classe AmazonSimpleWorkflowClient usada para acessar os métodos SWF.

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

Adicione o método main. O método fica em loop continuamente, fazendo uma sondagem de tarefas de decisão usando o método pollForDecisionTask do cliente do SWF. O PollForDecisionTaskRequest apresenta os detalhes.

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

Assim que uma tarefa for recebida, chamaremos o método getTaskToken, que retornará uma string que poderá ser usada para identificar a tarefa. Se o token retornado não for null, processaremos ainda mais no método executeDecisionTask, passando o token da tarefa e a lista de objetos HistoryEvent enviados com a tarefa.

Adicione o método executeDecisionTask, utilizando o token da tarefa (uma String) e a lista 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;

Também configuramos alguns membros de dados para acompanhar coisas como:

Em seguida, adicione um código a executeDecisionTask para processar os objetos HistoryEvent que foram enviados com a tarefa, com base no tipo de evento informado pelo método 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("]");

Tendo em vista o fluxo de trabalho, estamos mais interessados:

Os outros tipos de evento poderão ser usados se o fluxo de trabalho precisar deles. Consulte a descrição da classe HistoryEvent para obter informações sobre cada tipo de evento.

+ OBSERVAÇÃO: as strings em instruções switch foram introduzidas no Java 7. Se estiver usando uma versão anterior do Java, será possível usar a classe EventType para converter a String retornado por history_event.getType() em um valor enum e novamente em uma String, se necessário:

Depois da instrução switch, adicione mais código para responder com uma decisão apropriada com base na tarefa que foi recebida.

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

Em qualquer um dos casos, as informações sobre a decisão são adicionadas à lista Decision que foi declarada na parte superior do método.

Conclua a tarefa de decisão retornando a lista de objetos Decision coletados durante o processamento da tarefa. Adicione esse código ao final do método executeDecisionTask que estávamos escrevendo:

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

O método respondDecisionTaskCompleted do cliente do SWF utiliza o token da tarefa que identifica a tarefa, bem como a lista de objetos Decision.

Abra o editor de textos e crie o arquivo WorkflowStarter.java, adicionando uma declaração de pacote e importações de acordo com as etapas comuns.

Adicione a 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() + "'.");
    }
}

A classe WorkflowStarter consiste em um único método main, que utiliza um argumento opcional passado na linha de comando como dados de entrada para o fluxo de trabalho.

O método de cliente do SWF, startWorkflowExecution, utiliza um objeto StartWorkflowExecutionRequest como entrada. Aqui, além de especificar o domínio e o tipo de fluxo de trabalho para execução, fornecemos:

O objeto Executar que startWorkflowExecution retorna fornece um ID de execução, um valor que pode ser usado para identificar a execução desse fluxo de trabalho em especial no histórico do Amazon SWF das execuções de fluxo de trabalho.

+ OBSERVAÇÃO: o ID de execução é gerado pelo Amazon SWF e não tem o mesmo nome de execução do fluxo de trabalho passado por você ao iniciar a execução do fluxo de trabalho.