public static async Task <JToken> ExecuteAsync(this InvokeSubflowAction action,
StateMachineContext context,
JToken input)
{
action.CheckArgNull(nameof(action));
context.CheckArgNull(nameof(context));
input.CheckArgNull(nameof(input));
Func <CancellationToken, Task <JToken> > invokeTask = async token =>
{
var jobj = await context.Host.ExecuteSubflowAsync(action.SubflowName, input, token, action.WaitForCompletion);
Debug.Assert(jobj != null);
return(jobj);
};
JToken output;
if (action.Timeout != null)
{
using var localTimeoutCancelTokenSource = new CancellationTokenSource();
using var combined = CancellationTokenSource.CreateLinkedTokenSource(
localTimeoutCancelTokenSource.Token, context.CancelToken);
Task <JToken> timeoutTask = context.Host.DelayAsync(action.Timeout.Value, combined.Token)
.ContinueWith(_ =>
{
return((JToken)JValue.CreateNull());
});
Debug.Assert(timeoutTask != null);
output = await Task.WhenAny(timeoutTask, invokeTask(combined.Token)).Unwrap();
if (!timeoutTask.IsCompleted)
{
localTimeoutCancelTokenSource.Cancel();
}
}
else
{
output = await invokeTask(context.CancelToken);
}
Debug.Assert(output != null);
return(output);
}
public static async Task <JToken> ExecuteAsync(this ModelAction action,
StateMachineContext context,
JToken input)
{
action.CheckArgNull(nameof(action));
context.CheckArgNull(nameof(context));
input.CheckArgNull(nameof(input));
await context.RecordObservableActionAsync(ObservableAction.BeforeAction,
() => new Dictionary <string, object>
{
{ "actionName", action.Name },
{ "actionType", action.GetType().FullName }
});
Func <StateMachineContext, JToken, Task <JToken> > executeFunc = action switch
{
InjectDataAction inject => inject.ExecuteAsync,
ParallelAction parallel => parallel.ExecuteAsync,
SequenceAction sequence => sequence.ExecuteAsync,
SendEventAction send => send.ExecuteAsync,
DelayAction delay => delay.ExecuteAsync,
InvokeSubflowAction subflow => subflow.ExecuteAsync,
InvokeFunctionAction function => function.ExecuteAsync,
ForEachAction forEach => forEach.ExecuteAsync,
_ => throw new NotImplementedException("Action behavior not implemented: " + action.GetType().FullName)
};
Debug.Assert(executeFunc != null);
var attempts = 0;
DateTimeOffset?start = null;
while (true)
{
try
{
var result = await executeFunc(context, input);
await context.RecordObservableActionAsync(ObservableAction.AfterAction,
() => new Dictionary <string, object>
{
{ "actionName", action.Name },
{ "actionType", action.GetType().FullName }
});
return(result);
}
catch (Exception ex)
{
if (action.TryHandleError(JObject.FromObject(ex),
context,
out RetryPolicy? retryPolicy))
{
if (retryPolicy == null)
{
return(JValue.CreateNull());
}
else
{
TimeSpan elapsedDelay;
if (start == null)
{
start = DateTimeOffset.UtcNow;
elapsedDelay = TimeSpan.Zero;
}
else
{
elapsedDelay = DateTimeOffset.UtcNow.Subtract(start.Value);
}
var retry = await retryPolicy.ShouldRetryAsync(context, ++attempts, elapsedDelay);
if (retry)
{
continue;
}
}
}
throw;
}
}
}