brainslug.flow.node.task

Class AbstractTaskDefinition<SelfType extends AbstractTaskDefinition>

java.lang.Object

brainslug.util.MixableBase<FlowNodeDefinition>

brainslug.flow.node.FlowNodeDefinition<SelfType>

brainslug.flow.node.task.AbstractTaskDefinition<SelfType>

All Implemented Interfaces:

Mixable<FlowNodeDefinition>

Direct Known Subclasses:

TaskDefinition

public abstract class AbstractTaskDefinition<SelfType extends AbstractTaskDefinition>
extends FlowNodeDefinition<SelfType>

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	async
protected Class<?>	delegateClass
protected Identifier	goalId
protected CallDefinition	methodCall
protected boolean	retryAsync
protected RetryStrategy	retryStrategy

Constructor Summary

Constructors

Constructor and Description
AbstractTaskDefinition()

Method Summary

Modifier and Type	Method and Description
SelfType	async(boolean async) flag the task for async execution.
SelfType	call(CallDefinition methodCall) sets a method invocation as action for this task Example:
SelfType	delegate(Class<?> delegateClass) sets a delegate class to be executed as action for this task Example:
Class<?>	getDelegateClass()
Option<Identifier>	getGoal()
CallDefinition	getMethodCall()
Option<RetryStrategy>	getRetryStrategy()
SelfType	goal(GoalDefinition goal) A goal groups tasks by the outcome they contribute to.
SelfType	goal(Identifier goalId)
boolean	isAsync()
boolean	isRetryAsync()
SelfType	retryAsync(boolean retryAsync) flag the task for async execution in case of error.
SelfType	retryStrategy(RetryStrategy retryStrategy) set the retry strategy in case of async execution.

Methods inherited from class brainslug.flow.node.FlowNodeDefinition

addIncoming, addOutgoing, display, documentation, equals, getDisplayName, getId, getIncoming, getOutgoing, hashCode, id, id, id, self, toString

Methods inherited from class brainslug.util.MixableBase

as, is, with, with

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

delegateClass

protected Class<?> delegateClass

async

protected boolean async

retryAsync

protected boolean retryAsync

methodCall

protected CallDefinition methodCall

goalId

protected Identifier goalId

retryStrategy

protected RetryStrategy retryStrategy

Constructor Detail

AbstractTaskDefinition

public AbstractTaskDefinition()

Method Detail

delegate

public SelfType delegate(Class<?> delegateClass)

sets a delegate class to be executed as action for this task Example:

  {@literal @}Override public void define() {
   start(event(id(START)))
   .execute(task(id(TASK)).delegate(Delegate.class))
   .end(event(id(END)));
   }
 
 

Parameters:

delegateClass - type of the delegate class for lookup in the Registry

Returns:

the task definition

call

public SelfType call(CallDefinition methodCall)

sets a method invocation as action for this task Example:

  {@literal @}Override public void define() {
   start(event(id(START)))
   .execute(task(id(TASK)).call(method(TestService.class).name("getString")))
   .end(event(id(END)));
   }
 
 

Parameters:

methodCall - the method invocation

Returns:

the task definition

async

public SelfType async(boolean async)

flag the task for async execution. The execution will be paused and continued asynchronously when reaching this task. Example:

  {@literal @}Override public void define() {
   start(event(id(START)))
   .execute(task(id(TASK)).async(true))
   .end(event(id(END)));
   }
 
 

Parameters:

async - true if task execution should be async

Returns:

the task definition

retryAsync

public SelfType retryAsync(boolean retryAsync)

flag the task for async execution in case of error. The execution will be paused and continued asynchronously when the execution of this task fails. Be aware that this will not be possible int transactional environments if the transaction is already set to rollback because of the error. Example:

  {@literal @}Override public void define() {
   start(event(id(START)))
   .execute(task(id(TASK)).retryAsync(true))
   .end(event(id(END)));
   }
 
 

Parameters:

retryAsync - true if task execution should be scheduled for async retry

Returns:

the task definition

retryStrategy

public SelfType retryStrategy(RetryStrategy retryStrategy)

set the retry strategy in case of async execution. Example:

  new FlowBuilder() {
   {@literal @}Override
   public void define() {
   GoalDefinition testGoal = goal(id("aGoal")).check(predicate(goalCondition));

   start(id("start"))
   .execute(task(id("simpleTask")).retryAsync(true).retryStrategy(retryStrategy))
   .end(id("end"));
   }
 }
 
 

Parameters:

retryStrategy - the retry strategy

Returns:

this task definition with retryStrategy defined

goal

public SelfType goal(GoalDefinition goal)

A goal groups tasks by the outcome they contribute to. Tasks with a goal defined will only be executed if the goal is not fulfilled yet. Goals must have a predicate to check the state of fulfilment. Example:

  new FlowBuilder() {
     {@literal @}Override
     public void define() {
       GoalDefinition testGoal = goal(id("aGoal")).check(predicate(goalCondition));

       start(event(id("START")))
       .execute(task(id("TASK"), simpleTask).goal(testGoal))
       .end(event(id("END")));
     }
  }
 
 

Parameters:

goal - the goal this task belongs to

Returns:

this task definition with goal defined

goal

public SelfType goal(Identifier goalId)

getDelegateClass

public Class<?> getDelegateClass()

getMethodCall

public CallDefinition getMethodCall()

getGoal

public Option<Identifier> getGoal()

isAsync

public boolean isAsync()

isRetryAsync

public boolean isRetryAsync()

getRetryStrategy

public Option<RetryStrategy> getRetryStrategy()