Contexte d'exécution

L'infrastructure fournit un contexte ambiant aux implémentations de flux de travail et d'activité. Ce contexte est propre à la tâche en cours de traitement et fournit certains utilitaires que vous pouvez utiliser dans votre implémentation. Un objet de contexte est créé chaque fois qu'une nouvelle tâche est traitée par l'exécuteur.

Contexte décisionnel

Lorsqu'une tâche de décision est exécutée, elle fournit le contexte de la mise en œuvre du flux de travail grâce à la classe DecisionContext. DecisionContext fournit des informations contextuelles telles que les ID d'exécution de flux de travail, et les fonctionnalités d'horloge et de minuteur.

Accès à la classe DecisionContext dans l'implémentation du flux de travail

Vous pouvez accéder à la classe DecisionContext dans l'implémentation de votre flux de travail à l'aide de la classe DecisionContextProviderImpl. Vous pouvez également injecter le contexte dans un champ ou une propriété de l'implémentation de votre flux de travail à l'aide de Spring comme illustré dans la section Injection de la testabilité et de la dépendance.

DecisionContextProvider contextProvider
    = new DecisionContextProviderImpl();
DecisionContext context = contextProvider.getDecisionContext();

Création d'une horloge et d'un minuteur

La classe DecisionContext contient une propriété de type WorkflowClock qui fournit une fonction de minuteur et d'horloge. Étant donné que la logique de flux de travail se doit être déterministe, vous ne devriez pas utiliser directement l'horloge système dans l'implémentation de votre flux de travail. La méthode currentTimeMills sur la classe WorkflowClock renvoie l'heure de l'événement de début de la décision en cours de traitement. Cela veille à ce que vous obteniez la même valeur temporelle pendant la reproduction, d'où l'importance d'une logique de flux de travail déterministe.

La classe WorkflowClock possède également une méthode createTimer qui renvoie un objet Promise qui sera prêt après l'intervalle spécifié. Vous pouvez utiliser cette valeur en tant que paramètre pour les autres méthodes asynchrones afin de retarder leur exécution de la durée spécifiée. De cette manière, vous pouvez efficacement planifier une méthode ou une activité asynchrone en vue d'une exécution ultérieure.

L'exemple de la liste suivante montre comment utiliser appeler une activité périodiquement.

@Workflow
@WorkflowRegistrationOptions(defaultExecutionStartToCloseTimeoutSeconds = 60,
               defaultTaskStartToCloseTimeoutSeconds = 10)
public interface PeriodicWorkflow {

    @Execute(version = "1.0")
    void periodicWorkflow();
}

@Activities(version = "1.0")
@ActivityRegistrationOptions(defaultTaskScheduleToStartTimeoutSeconds = 300,
                             defaultTaskStartToCloseTimeoutSeconds = 3600)
public interface PeriodicActivity {
    void activity1();
}

public class PeriodicWorkflowImpl implements PeriodicWorkflow {

    private DecisionContextProvider contextProvider
         = new DecisionContextProviderImpl();

    private WorkflowClock clock
         = contextProvider.getDecisionContext().getWorkflowClock();

    @Override
    public void periodicWorkflow() {
        callPeriodicActivity(0);
    }

    @Asynchronous
    private void callPeriodicActivity(int count,
                                      Promise<?>... waitFor) {
        if (count == 100) {
            return;
        }
        PeriodicActivityClient client = new PeriodicActivityClientImpl();
        // call activity
        Promise<Void> activityCompletion = client.activity1();

        Promise<Void> timer = clock.createTimer(3600);

        // Repeat the activity either after 1 hour or after previous activity run
        // if it takes longer than 1 hour
        callPeriodicActivity(count + 1, timer, activityCompletion);
    }
}


public class PeriodicActivityImpl implements PeriodicActivity
{
@Override
   public void activity1() {
      ...
      }
}      

Dans la liste ci-dessus, la méthode asynchrone callPeriodicActivity appelle un objet activity1, puis crée un minuteur à l'aide de la classe AsyncDecisionContext actuelle. Elle transmet l'objet Promise renvoyé en tant qu'argument à un appel récursif à elle-même. Cet appel récursif patiente jusqu'à ce que le minuteur se déclenche (1 heure dans cet exemple) avant l'exécution.

Contexte d'exécution d'une activité

De la même manière que la classe DecisionContext fournit des informations contextuelles lorsqu'une tâche de décision est traitée, la classe ActivityExecutionContext fournit des informations contextuelles similaires lorsqu'une tâche d'activité est en cours de traitement. Ce contexte est disponible depuis votre code d'activité via la classe ActivityExecutionContextProviderImpl.

ActivityExecutionContextProvider provider
    = new ActivityExecutionContextProviderImpl();
ActivityExecutionContext aec = provider.getActivityExecutionContext();

À l'aide la classe ActivityExecutionContext, vous pouvez exécuter les activités suivantes :

Vérification des pulsations d'une activité de longue durée

Si l'activité est de longue durée, elle doit signaler périodiquement sa progression à Amazon SWF afin de lui indiquer que la tâche est toujours en cours. En cas d'absence de pulsations, le délai d'attente de la tâche peut être dépassé si un délai de pulsation de la tâche a été défini lors de l'enregistrement du type d'activité ou de la planification de l'activité. Afin d'envoyer une pulsation, vous pouvez utiliser la méthode recordActivityHeartbeat sur la classe ActivityExecutionContext. Heartbeat fournit également un mécanisme pour annuler les activités en cours. Consultez la section Gestion des erreurs pour en savoir plus et obtenir un exemple.

Obtention des détails de la tâche d'activité

Si vous le souhaitez, vous pouvez obtenir tous les détails de la tâche d'activité qui ont été transmis via Amazon SWF lorsque l'exécuteur a reçu la tâche. Cela comprend les informations concernant les entrées de la tâche, son type, son jeton, etc. Si vous souhaitez implémenter une activité terminée manuellement—par une action humainquevous devez utiliser laActivityExecutionContextpour récupérer le jeton de la tâche et le transmettre au processus qui terminera la tâche d'activité. Pour en savoir plus, consultez la section sur Finalisation manuelle des activités.

Obtraction de l'objet client Amazon SWF en cours d'utilisation par l'exécuteur

L'objet client Amazon SWF en cours d'utilisation par l'exécuteur peut être récupéré en appelantgetServicesurActivityExecutionContext. Cela est utile si vous souhaitez effectuer un appel direct au service Amazon SWF.