/// <inheritdoc/>
protected override IWorkflowActivityProcessor CreateProcessorFor(V1WorkflowActivity activity)
{
IWorkflowActivityProcessor processor = base.CreateProcessorFor(activity);
CancellationToken cancellationToken = this.CancellationTokenSource.Token;
switch (processor)
{
case ConsumeEventProcessor consumeEventProcessor:
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>().SubscribeAsync
(
async result => await this.OnEventResultAsync(consumeEventProcessor, result, cancellationToken),
async ex => await this.OnErrorAsync(ex, cancellationToken),
async() => await this.OnEventCompletedAsync(consumeEventProcessor, cancellationToken)
);
break;
case ActionProcessor actionProcessor:
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>().SubscribeAsync
(
async result => await this.OnActionResultAsync(actionProcessor, result, cancellationToken),
async ex => await this.OnErrorAsync(ex, cancellationToken),
async() => await this.OnActionCompletedAsync(actionProcessor, cancellationToken)
);
break;
default:
throw new NotSupportedException($"The specified execution pointer type '{processor.GetType().Name}' is not supported in this context");
}
return(processor);
}
/// <inheritdoc/>
public virtual IWorkflowActivityProcessor Create(V1WorkflowActivity activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (!activity.Metadata.TryGetValue(V1WorkflowActivityMetadata.State, out var stateName))
{
throw new ArgumentException($"The specified activity '{activity.Id}' is missing the required metadata field '{V1WorkflowActivityMetadata.State}'");
}
if (!this.Context.Workflow.Definition.TryGetState(stateName, out var state))
{
throw new NullReferenceException($"Failed to find the workflow state with the specified name '{stateName}'");
}
try
{
return(activity.Type switch
{
V1WorkflowActivityType.Action => this.CreateActionActivityProcessor(state, activity),
V1WorkflowActivityType.Branch => this.CreateBranchActivityProcessor(state, activity),
V1WorkflowActivityType.ConsumeEvent => this.CreateConsumeEventActivityProcessor(activity),
V1WorkflowActivityType.End => ActivatorUtilities.CreateInstance <EndProcessor>(this.ServiceProvider, activity, state.End ?? new()),
V1WorkflowActivityType.Error => throw new NotImplementedException(),//todo
V1WorkflowActivityType.EventTrigger => this.CreateEventStateTriggerActivityProcessor(state, activity),
V1WorkflowActivityType.Iteration => this.CreateIterationActivityProcessor(state, activity),
V1WorkflowActivityType.ProduceEvent => this.CreateProduceEventActivityProcessor(activity),
V1WorkflowActivityType.Start => ActivatorUtilities.CreateInstance <StartProcessor>(this.ServiceProvider, activity, this.Context.Workflow.Definition.Start ?? new()),
V1WorkflowActivityType.State => this.CreateStateActivityProcessor(state, activity),
V1WorkflowActivityType.SubFlow => this.CreateSubflowActivityProcessor(state, activity),
V1WorkflowActivityType.Transition => this.CreateTransitionActivityProcessor(state, activity),
_ => throw new NotSupportedException($"The specified {typeof(V1WorkflowActivityType).Name} '{activity.Type}' is not supported"),
});
}
/// <inheritdoc/>
protected override IWorkflowActivityProcessor CreateProcessorFor(V1WorkflowActivity activity)
{
var processor = base.CreateProcessorFor(activity);
var cancellationToken = this.CancellationTokenSource.Token;
switch (processor)
{
case ProduceEventProcessor produceEventProcessor:
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>()
.SubscribeAsync
(
async result => await this.OnProduceEventResultAsync(result, cancellationToken),
async ex => await this.OnErrorAsync(ex, cancellationToken),
async() => await this.OnProduceEventCompletedAsync(processor, cancellationToken)
);
break;
case ConsumeEventProcessor consumeEventProcessor:
processor.SubscribeAsync
(
async result => await this.OnConsumeEventResultAsync(result, cancellationToken),
async ex => await this.OnErrorAsync(ex, cancellationToken),
async() => await this.OnConsumeEventCompletedAsync(processor, cancellationToken)
);
break;
default:
processor.Dispose();
throw new NotSupportedException($"The specified {nameof(IWorkflowActivityProcessor)} '{processor.GetType()}' is not supported");
}
return(processor);
}
/// <summary>
/// Initializes a new <see cref="WorkflowActivityProcessor"/>
/// </summary>
/// <param name="serviceProvider">The current <see cref="IServiceProvider"/></param>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="context">The current <see cref="IWorkflowRuntimeContext"/></param>
/// <param name="activityProcessorFactory">The service used to create <see cref="IWorkflowActivityProcessor"/>s</param>
/// <param name="options">The service used to access the current <see cref="ApplicationOptions"/></param>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to process</param>
/// <param name="action">The <see cref="ActionDefinition"/> to process</param>
/// <param name="function">The <see cref="FunctionDefinition"/> to process</param>
public FunctionProcessor(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory,
IOptions <ApplicationOptions> options, V1WorkflowActivity activity, ActionDefinition action, FunctionDefinition function)
: base(loggerFactory, context, activityProcessorFactory, options, activity, action)
{
this.ServiceProvider = serviceProvider;
this.Function = function;
}
/// <summary>
/// Initializes a new <see cref="TransitionProcessor"/>
/// </summary>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="context">The current <see cref="IWorkflowRuntimeContext"/></param>
/// <param name="activityProcessorFactory">The service used to create <see cref="IWorkflowActivityProcessor"/>s</param>
/// <param name="options">The service used to access the current <see cref="ApplicationOptions"/></param>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to process</param>
/// <param name="state">The <see cref="StateDefinition"/> to process the transition of</param>
/// <param name="transition">The <see cref="TransitionDefinition"/> to process</param>
public TransitionProcessor(ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory,
IOptions <ApplicationOptions> options, V1WorkflowActivity activity, StateDefinition state, TransitionDefinition transition)
: base(loggerFactory, context, activityProcessorFactory, options, activity)
{
this.State = state;
this.Transition = transition;
}
/// <summary>
/// Initializes a new <see cref="WorkflowActivityProcessor"/>
/// </summary>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="context">The current <see cref="IWorkflowRuntimeContext"/></param>
/// <param name="activityProcessorFactory">The service used to create <see cref="IWorkflowActivityProcessor"/>s</param>
/// <param name="jsonSerializer">The service used to serialize/deserialize to/from JSON</param>
/// <param name="options">The service used to access the current <see cref="ApplicationOptions"/></param>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to process</param>
/// <param name="state">The <see cref="EventStateDefinition"/> to process</param>
/// <param name="trigger">The <see cref="EventStateTriggerDefinition"/> to process</param>
public EventStateTriggerProcessor(ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory, IJsonSerializer jsonSerializer,
IOptions <ApplicationOptions> options, V1WorkflowActivity activity, EventStateDefinition state, EventStateTriggerDefinition trigger)
: base(loggerFactory, context, activityProcessorFactory, options, activity)
{
this.JsonSerializer = jsonSerializer;
this.State = state;
this.Trigger = trigger;
}
/// <inheritdoc/>
public virtual async Task CancelActivityAsync(V1WorkflowActivity activity, CancellationToken cancellationToken = default)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
await this.SynapseRuntimeApi.CancelActivityAsync(activity.Id, cancellationToken);
}
/// <inheritdoc/>
public virtual async Task SetActivityMetadataAsync(V1WorkflowActivity activity, CancellationToken cancellationToken = default)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
await this.SynapseRuntimeApi.SetActivityMetadataAsync(new() { Id = activity.Id, Metadata = activity.Metadata }, cancellationToken);
}
/// <summary>
/// Initializes a new <see cref="AsyncFunctionProcessor"/>
/// </summary>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="context">The current <see cref="IWorkflowRuntimeContext"/></param>
/// <param name="activityProcessorFactory">The service used to create <see cref="IWorkflowActivityProcessor"/>s</param>
/// <param name="options">The service used to access the current <see cref="ApplicationOptions"/></param>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to process</param>
/// <param name="state">The <see cref="StateDefinition"/> the <see cref="EventReference"/> to process belongs to</param>
/// <param name="action">The <see cref="ActionDefinition"/> to process</param>
/// <param name="triggerEvent">The <see cref="EventDefinition"/> that defines the <see cref="CloudEvent"/> to produce, thus triggering the async call</param>
/// <param name="resultEvent">The <see cref="EventDefinition"/> that defines the <see cref="CloudEvent"/> to consume, thus ending the async call</param>
public AsyncFunctionProcessor(ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory,
IOptions <ApplicationOptions> options, V1WorkflowActivity activity, StateDefinition state, ActionDefinition action, EventDefinition triggerEvent, EventDefinition resultEvent)
: base(loggerFactory, context, activityProcessorFactory, options, activity, action)
{
this.State = state;
this.TriggerEvent = triggerEvent;
this.ResultEvent = resultEvent;
}
/// <summary>
/// Resumes the execution of the workflow from the <see cref="EndDefinition"/>
/// </summary>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to resume from</param>
/// <returns>A new awaitable <see cref="Task"/></returns>
protected virtual async Task ResumeFromEndAsync(V1WorkflowActivity activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
await this.Context.Workflow.SetOutputAsync(activity.Output, this.CancellationToken);
}
/// <summary>
/// Resumes the execution of the workflow from the <see cref="StartDefinition"/>
/// </summary>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to resume from</param>
/// <returns>A new awaitable <see cref="Task"/></returns>
protected virtual Task ResumeFromStartAsync(V1WorkflowActivity activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
//todo: implement
throw new NotImplementedException();
}
/// <summary>
/// Resumes the execution of the workflow from the specified <see cref="TransitionDefinition"/>
/// </summary>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to resume from</param>
/// <returns>A new awaitable <see cref="Task"/></returns>
protected virtual async Task ResumeFromTransitionAsync(V1WorkflowActivity activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (!activity.Metadata.TryGetValue(V1WorkflowActivityMetadata.State, out var stateName))
{
throw new ArgumentException($"The specified activity '{activity.Id}' is missing the required metadata field '{V1WorkflowActivityMetadata.State}'");
}
if (!this.Context.Workflow.Definition.TryGetState(stateName, out var state))
{
throw new NullReferenceException($"Failed to find the workflow state with the specified name '{stateName}'");
}
TransitionDefinition transition;
if (state is SwitchStateDefinition @switch)
{
if (!activity.Metadata.TryGetValue(V1WorkflowActivityMetadata.Case, out var caseName))
{
throw new ArgumentException($"The specified activity '{activity.Id}' is missing the required metadata field '{V1WorkflowActivityMetadata.Case}'");
}
if ([email protected](caseName, out SwitchCaseDefinition dataCondition))
{
throw new NullReferenceException($"Failed to find a condition with the specified name '{caseName}'");
}
transition = dataCondition.Transition !;
if (transition == null)
{
transition = new() { NextState = dataCondition.TransitionToStateName ! }
}
;
}
else
{
transition = state.Transition !;
if (transition == null)
{
transition = new() { NextState = state.TransitionToStateName ! }
}
;
}
if (!this.Context.Workflow.Definition.TryGetState(transition.NextState, out StateDefinition nextState))
{
throw new NullReferenceException($"Failed to find a state with name '{transition.NextState}' in workflow '{this.Context.Workflow.Definition.Id} {this.Context.Workflow.Definition.Version}'");
}
await this.Context.Workflow.TransitionToAsync(nextState, this.CancellationToken);
var metadata = new Dictionary <string, string>()
{
{ V1WorkflowActivityMetadata.State, nextState.Name }
};
var nextActivity = await this.Context.Workflow.CreateActivityAsync(V1WorkflowActivityType.State, activity.Output, metadata, null, this.CancellationToken);
var processor = this.CreateActivityProcessor(nextActivity);
await processor.ProcessAsync(this.CancellationToken);
}
/// <inheritdoc/>
public virtual async Task FaultActivityAsync(V1WorkflowActivity activity, Integration.Models.Error error, CancellationToken cancellationToken = default)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (error == null)
{
throw new ArgumentNullException(nameof(error));
}
await this.SynapseRuntimeApi.FaultActivityAsync(new() { Id = activity.Id, Error = error }, cancellationToken);;
}
/// <inheritdoc/>
protected override IWorkflowActivityProcessor CreateProcessorFor(V1WorkflowActivity activity)
{
var processor = (ActionProcessor)base.CreateProcessorFor(activity);
processor.SubscribeAsync
(
async e => await this.OnNextActionAsync(processor, e),
async ex => await this.OnActionFaultedAsync(processor, ex),
async() => await this.OnActionCompletedAsync(processor)
);
return(processor);
}
/// <inheritdoc/>
protected override IWorkflowActivityProcessor CreateProcessorFor(V1WorkflowActivity activity)
{
var processor = (EventStateTriggerProcessor)base.CreateProcessorFor(activity);
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>().SubscribeAsync
(
async result => await this.OnTriggerResultAsync(processor, result, this.CancellationTokenSource.Token),
async ex => await this.OnErrorAsync(ex, this.CancellationTokenSource.Token),
async() => await this.OnTriggerCompletedAsync(processor, this.CancellationTokenSource.Token)
);
return(processor);
}
/// <inheritdoc/>
protected override IWorkflowActivityProcessor CreateProcessorFor(V1WorkflowActivity activity)
{
var cancellationToken = this.CancellationTokenSource.Token;
var processor = (BranchProcessor)base.CreateProcessorFor(activity);
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>().SubscribeAsync
(
async e => await this.OnBranchExecutedAsync(processor, e, cancellationToken),
async ex => await this.OnErrorAsync(ex, cancellationToken),
async() => await this.OnBranchCompletedAsync(processor, cancellationToken)
);
return(processor);
}
public static IWorkflowNodeViewModel?GetNodeFor(this IGraphViewModel graph, V1WorkflowActivity activity)
{
if (activity == null)
{
return(null);
}
switch (activity.Type)
{
case V1WorkflowActivityType.Action:
return(graph.GetActionNodeFor(activity));
case V1WorkflowActivityType.Function:
return(graph.GetActionNodeFor(activity));
case V1WorkflowActivityType.Transition:
return(graph.GetTransitionNodeFor(activity));
case V1WorkflowActivityType.Branch:
throw new NotImplementedException(); //todo
case V1WorkflowActivityType.ConsumeEvent:
throw new NotImplementedException(); //todo
case V1WorkflowActivityType.End:
return(graph.Nodes.Values.OfType <EndNodeViewModel>().FirstOrDefault());
case V1WorkflowActivityType.Error:
throw new NotImplementedException(); //todo
case V1WorkflowActivityType.EventTrigger:
throw new NotImplementedException(); //todo
case V1WorkflowActivityType.Iteration:
throw new NotImplementedException(); //todo
case V1WorkflowActivityType.ProduceEvent:
throw new NotImplementedException(); //todo
case V1WorkflowActivityType.Start:
return(graph.Nodes.Values.OfType <StartNodeViewModel>().FirstOrDefault());
case V1WorkflowActivityType.State:
return(graph.GetStateNodeFor(activity));
case V1WorkflowActivityType.SubFlow:
throw new NotImplementedException(); //todo
default:
return(null);
}
}
/// <inheritdoc/>
public virtual async Task SetActivityOutputAsync(V1WorkflowActivity activity, object?output, CancellationToken cancellationToken = default)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
var outputParam = output as Dynamic;
if (outputParam == null && output != null)
{
outputParam = Dynamic.FromObject(output);
}
await this.SynapseRuntimeApi.SetActivityOutputAsync(new() { Id = activity.Id, Output = outputParam }, cancellationToken);
}
/// <inheritdoc/>
public virtual async Task FaultActivityAsync(V1WorkflowActivity activity, Exception ex, CancellationToken cancellationToken = default)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (ex == null)
{
throw new ArgumentNullException(nameof(ex));
}
await this.FaultActivityAsync(activity, new Integration.Models.Error()
{
Code = ex.GetType().Name.Replace("exception", string.Empty, StringComparison.OrdinalIgnoreCase), Message = ex.Message
}, cancellationToken);
}
/// <inheritdoc/>
public virtual async Task On(V1WorkflowActivity activity, IV1WorkflowActivityIntegrationEvent e, CancellationToken cancellationToken = default)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
switch (e)
{
case V1WorkflowActivityStartedIntegrationEvent:
case V1WorkflowActivityResumedIntegrationEvent:
await this.StartOrResumeActivityAsync(activity, cancellationToken);
break;
case V1WorkflowActivitySuspendedIntegrationEvent:
await this.SuspendActivityAsync(activity, cancellationToken);
break;
case V1WorkflowActivitySkippedIntegrationEvent:
await this.SkipActivityAsync(activity, cancellationToken);
break;
case V1WorkflowActivityFaultedIntegrationEvent faultedEvent:
await this.FaultActivityAsync(activity, faultedEvent.Error, cancellationToken);
break;
case V1WorkflowActivityCancelledIntegrationEvent:
await this.CancelActivityAsync(activity, cancellationToken);
break;
case V1WorkflowActivityCompletedIntegrationEvent completedEvent:
await this.SetActivityOutputAsync(activity, completedEvent.Output, cancellationToken);
break;
default:
throw new NotSupportedException($"The specified workflow activity integration event type '{e.GetType().Name}' is not supported in this context");
}
}
/// <summary>
/// Creates a new child <see cref="IWorkflowActivityProcessor"/> for the specified <see cref="V1WorkflowActivity"/>
/// </summary>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to create a child <see cref="IWorkflowActivityProcessor"/> for</param>
protected virtual IWorkflowActivityProcessor CreateActivityProcessor(V1WorkflowActivity activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
IWorkflowActivityProcessor processor = this.ActivityProcessorFactory.Create(activity);
switch (processor)
{
case IStateProcessor stateProcessor:
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>().SubscribeAsync
(
async e => await this.OnStateCompletedAsync(stateProcessor, e),
async ex => await this.OnActivityProcessingErrorAsync(stateProcessor, ex),
async() => await this.OnActivityProcessingCompletedAsync(stateProcessor)
);
break;
case ITransitionProcessor transitionProcessor:
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>().SubscribeAsync
(
async e => await this.OnTransitionCompletedAsync(transitionProcessor, e),
async ex => await this.OnActivityProcessingErrorAsync(transitionProcessor, ex),
async() => await this.OnActivityProcessingCompletedAsync(transitionProcessor)
);
break;
case IEndProcessor endProcessor:
processor.OfType <V1WorkflowActivityCompletedIntegrationEvent>().SubscribeAsync
(
async e => await this.OnEndCompletedAsync(endProcessor, e),
async ex => await this.OnActivityProcessingErrorAsync(endProcessor, ex),
async() => await this.OnCompletedAsync(endProcessor)
);
break;
}
this.Processors.Add(processor);
return(processor);
}
/// <summary>
/// Resumes the execution of the workflow from the specified <see cref="StateDefinition"/>
/// </summary>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to resume from</param>
/// <returns>A new awaitable <see cref="Task"/></returns>
protected virtual async Task ResumeFromStateAsync(V1WorkflowActivity activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (!activity.Metadata.TryGetValue(V1WorkflowActivityMetadata.State, out var stateName))
{
throw new ArgumentException($"The specified activity '{activity.Id}' is missing the required metadata field '{V1WorkflowActivityMetadata.State}'");
}
if (!this.Context.Workflow.Definition.TryGetState(stateName, out var state))
{
throw new NullReferenceException($"Failed to find the workflow state with the specified name '{stateName}'");
}
V1WorkflowActivity nextActivity;
var metadata = new Dictionary <string, string>()
{
{ V1WorkflowActivityMetadata.State, state.Name }
};
if (state.Transition != null ||
!string.IsNullOrWhiteSpace(state.TransitionToStateName))
{
nextActivity = await this.Context.Workflow.CreateActivityAsync(V1WorkflowActivityType.Transition, activity.Output !.ToObject() !, metadata, null, this.CancellationToken);
}
else if (state.End != null ||
state.IsEnd)
{
nextActivity = await this.Context.Workflow.CreateActivityAsync(V1WorkflowActivityType.End, activity.Output !.ToObject() !, metadata, null, this.CancellationToken);
}
else
{
throw new InvalidOperationException($"The state '{state.Name}' must declare a transition definition or an end definition for it is part of the main execution logic of the workflow '{this.Context.Workflow.Definition.Id}'");
}
var processor = this.CreateActivityProcessor(nextActivity);
await processor.ProcessAsync(this.CancellationToken);
}
private static IWorkflowNodeViewModel?GetTransitionNodeFor(this IGraphViewModel graph, V1WorkflowActivity activity)
{
var stateNode = (StateNodeViewModel)graph.GetStateNodeFor(activity) !;
if (!activity.Metadata.TryGetValue("case", out var caseName))
{
return(null);
}
return(stateNode.Children.Values.OfType <DataCaseNodeViewModel>().FirstOrDefault(node => node != null && node.DataCaseName == caseName));
}
private static IWorkflowNodeViewModel?GetActionNodeFor(this IGraphViewModel graph, V1WorkflowActivity activity)
{
var stateNode = (StateNodeViewModel)graph.GetStateNodeFor(activity) !;
if (!activity.Metadata.TryGetValue("action", out var actionName))
{
throw new InvalidDataException($"The specified activity's metadata does not define a 'action' value");
}
return(stateNode.Children.Values.Where(node => typeof(IActionNodeViewModel).IsAssignableFrom(node.GetType())).Select(node => node as IActionNodeViewModel).FirstOrDefault(node => node != null && node.Action.Name == actionName));
}
private static IWorkflowNodeViewModel?GetStateNodeFor(this IGraphViewModel graph, V1WorkflowActivity activity)
{
if (!activity.Metadata.TryGetValue("state", out var stateName))
{
throw new InvalidDataException($"The specified activity's metadata does not define a 'state' value");
}
return(graph.Clusters.Values.OfType <StateNodeViewModel>().FirstOrDefault(g => g.State.Name == stateName));
}
public AddV1WorkflowActivity(V1WorkflowActivity workflowActivity)
{
this.WorkflowActivity = workflowActivity;
}
/// <summary>
/// Initializes a new <see cref="WorkflowActivityProcessor"/>
/// </summary>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="context">The current <see cref="IWorkflowRuntimeContext"/></param>
/// <param name="activityProcessorFactory">The service used to create <see cref="IWorkflowActivityProcessor"/>s</param>
/// <param name="integrationEventBus">The service used to publish and subscribe to integration events</param>
/// <param name="options">The service used to access the current <see cref="ApplicationOptions"/></param>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to process</param>
/// <param name="eventDefinition">The <see cref="ServerlessWorkflow.Sdk.Models.EventDefinition"/> that defines the <see cref="V1Event"/> to consume</param>
public ConsumeEventProcessor(ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory,
IIntegrationEventBus integrationEventBus, IOptions <ApplicationOptions> options, V1WorkflowActivity activity, EventDefinition eventDefinition)
: base(loggerFactory, context, activityProcessorFactory, options, activity)
{
this.IntegrationEventBus = integrationEventBus;
this.EventDefinition = eventDefinition;
}
/// <inheritdoc/>
public ForEachStateProcessor(ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory,
IOptions <ApplicationOptions> options, V1WorkflowActivity activity, ForEachStateDefinition state)
: base(loggerFactory, context, activityProcessorFactory, options, activity, state)
{
}
/// <summary>
/// Initializes a new <see cref="WorkflowActivityProcessor"/>
/// </summary>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="context">The current <see cref="IWorkflowRuntimeContext"/></param>
/// <param name="activityProcessorFactory">The service used to create <see cref="IWorkflowActivityProcessor"/>s</param>
/// <param name="jsonSerializer">The service used to serialize/deserialize to/from JSON</param>
/// <param name="options">The service used to access the current <see cref="ApplicationOptions"/></param>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to process</param>
/// <param name="state">The <see cref="ParallelStateDefinition"/> that defines the <see cref="BranchDefinition"/> to process</param>
/// <param name="branch">The <see cref="BranchDefinition"/> to process</param>
public BranchProcessor(ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory,
IJsonSerializer jsonSerializer, IOptions <ApplicationOptions> options, V1WorkflowActivity activity, ParallelStateDefinition state, BranchDefinition branch)
: base(loggerFactory, context, activityProcessorFactory, options, activity)
{
this.JsonSerializer = jsonSerializer;
this.State = state;
this.Branch = branch;
}
/// <summary>
/// Initializes a new <see cref="ODataFunctionProcessor"/>
/// </summary>
/// <param name="serviceProvider">The current <see cref="IServiceProvider"/></param>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="context">The current <see cref="IWorkflowRuntimeContext"/></param>
/// <param name="activityProcessorFactory">The service used to create <see cref="IWorkflowActivityProcessor"/>s</param>
/// <param name="httpClientFactory">The service used to create <see cref="System.Net.Http.HttpClient"/>s</param>
/// <param name="serializerProvider">The service used to provide <see cref="ISerializer"/>s</param>
/// <param name="oauth2TokenManager">The service used to manahge <see cref="OAuth2Token"/>s</param>
/// <param name="options">The service used to access the current <see cref="ApplicationOptions"/></param>
/// <param name="activity">The <see cref="V1WorkflowActivity"/> to process</param>
/// <param name="action">The <see cref="ActionDefinition"/> to process</param>
/// <param name="function">The <see cref="FunctionDefinition"/> to process</param>
public ODataFunctionProcessor(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IWorkflowRuntimeContext context, IWorkflowActivityProcessorFactory activityProcessorFactory,
IHttpClientFactory httpClientFactory, ISerializerProvider serializerProvider, IOptions <ApplicationOptions> options, V1WorkflowActivity activity,
ActionDefinition action, FunctionDefinition function)
: base(serviceProvider, loggerFactory, context, activityProcessorFactory, options, activity, action, function)
{
this.HttpClient = httpClientFactory.CreateClient();
this.SerializerProvider = serializerProvider;
}