private async Task <IList <WorkflowTrigger> > GetTriggersForBookmarkProvider(
IBookmarkProvider provider,
BookmarkProviderContext context,
IActivityBlueprint activityBlueprint,
IWorkflowBlueprint workflowBlueprint,
CancellationToken cancellationToken = default)
{
var bookmarkResults = (await provider.GetBookmarksAsync(context, cancellationToken)).ToList();
return(bookmarkResults
.Select(x => new WorkflowTrigger(workflowBlueprint, activityBlueprint.Id, x.ActivityTypeName ?? activityBlueprint.Type, _bookmarkHasher.Hash(x.Bookmark), x.Bookmark))
.ToList());
}
public async ValueTask <RuntimeActivityInstance> ActivateActivityAsync(IActivityBlueprint activityBlueprint, CancellationToken cancellationToken = default)
{
var type = await GetActivityTypeAsync(activityBlueprint.Type, cancellationToken);
return(new RuntimeActivityInstance
{
ActivityType = type,
Id = activityBlueprint.Id,
Name = activityBlueprint.Name,
PersistWorkflow = activityBlueprint.PersistWorkflow,
LoadWorkflowContext = activityBlueprint.LoadWorkflowContext,
SaveWorkflowContext = activityBlueprint.SaveWorkflowContext
});
}
private BookmarkProviderContext GetBookmarkProviderContext(
IActivityBlueprint activity,
WorkflowExecutionContext workflowExecutionContext,
CancellationToken cancellationToken,
IDictionary <string, ActivityType> activityTypes)
{
var activityExecutionContext = _activityExecutionContextFactory.CreateActivityExecutionContext(
activity,
workflowExecutionContext,
cancellationToken);
var activityType = activityTypes[activity.Type];
return(new BookmarkProviderContext(activityExecutionContext, activityType, BookmarkIndexingMode.WorkflowBlueprint));
}
public ActivityExecutionContext(
IServiceProvider serviceProvider,
WorkflowExecutionContext workflowExecutionContext,
IActivityBlueprint activityBlueprint,
object?input,
bool resuming,
CancellationToken cancellationToken)
{
WorkflowExecutionContext = workflowExecutionContext;
ServiceProvider = serviceProvider;
ActivityBlueprint = activityBlueprint;
Input = input;
Resuming = resuming;
CancellationToken = cancellationToken;
Outcomes = new List <string>(0);
}
/// <summary>
/// Gets a collection of the workflow triggers for the specified activity blueprint.
/// </summary>
/// <param name="activityBlueprint">An activity blueprint</param>
/// <param name="workflowExecutionContext">A workflow execution context</param>
/// <param name="activityTypes">A dictionary of all of the activity types (by name)</param>
/// <param name="cancellationToken">An optional cancellation token</param>
/// <returns>A task exposing a collection of workflow triggers for the activity and workflow.</returns>
public async Task <IEnumerable <WorkflowTrigger> > GetTriggersForActivityBlueprintAsync(
IActivityBlueprint activityBlueprint,
WorkflowExecutionContext workflowExecutionContext,
IDictionary <string, ActivityType> activityTypes,
CancellationToken cancellationToken = default)
{
var bookmarkProviderContext = GetBookmarkProviderContext(activityBlueprint, workflowExecutionContext, cancellationToken, activityTypes);
var supportedBookmarkProviders = await GetSupportedBookmarkProvidersForContextAsync(bookmarkProviderContext)
.ToListAsync(cancellationToken);
var tasksOfListsOfTriggers = supportedBookmarkProviders
.Select(bookmarkProvider => GetTriggersForBookmarkProvider(bookmarkProvider,
bookmarkProviderContext,
activityBlueprint,
workflowExecutionContext.WorkflowBlueprint,
cancellationToken));
return((await Task.WhenAll(tasksOfListsOfTriggers))
.SelectMany(x => x)
.ToList());
}
/// <summary>
/// Creates a activity execution context for the specified activity blueprint.
/// </summary>
/// <param name="activityBlueprint">An activity blueprint</param>
/// <param name="workflowExecutionContext">A workflow execution context</param>
/// <param name="cancellationToken">A cancellation token</param>
/// <returns>An activity execution context</returns>
public ActivityExecutionContext CreateActivityExecutionContext(
IActivityBlueprint activityBlueprint,
WorkflowExecutionContext workflowExecutionContext,
CancellationToken cancellationToken) =>
public async Task GetTriggersForActivityBlueprintAsyncReturnsTriggersForEachBookmarkInSupportedBookmarkProviders(IBookmarkHasher bookmarkHasher,
IBookmarkProvider bookmarkProvider1,
IBookmarkProvider unsupportedBookmarkProvider,
IBookmarkProvider bookmarkProvider2,
ICreatesActivityExecutionContextForActivityBlueprint activityExecutionContextFactory,
[Frozen] IActivityBlueprint activityBlueprint,
[WithAutofixtureResolution, Frozen] IServiceProvider serviceProvider,
[Frozen] IWorkflowBlueprint workflowBlueprint,
[OmitOnRecursion, Frozen] WorkflowInstance workflowInstance,
[Frozen] WorkflowExecutionContext workflowExecutionContext,
[NoAutoProperties] ActivityExecutionContext activityExecutionContext,
ActivityType activityType,
IBookmark bookmark1,
IBookmark bookmark2,
IBookmark bookmark3,
IBookmark bookmark4)
{
var sut = new TriggersForActivityBlueprintAndWorkflowProvider(bookmarkHasher,
new[] { bookmarkProvider1, unsupportedBookmarkProvider, bookmarkProvider2 },
activityExecutionContextFactory);
Mock.Get(activityExecutionContextFactory)
.Setup(x => x.CreateActivityExecutionContext(activityBlueprint, workflowExecutionContext, default))
.Returns(activityExecutionContext);
Mock.Get(activityBlueprint).SetupGet(x => x.Type).Returns(activityType.TypeName);
Mock.Get(bookmarkProvider1)
.Setup(x => x.SupportsActivityAsync(It.Is <BookmarkProviderContext>(c => c.ActivityType == activityType), default))
.Returns(() => ValueTask.FromResult(true));
Mock.Get(unsupportedBookmarkProvider)
.Setup(x => x.SupportsActivityAsync(It.Is <BookmarkProviderContext>(c => c.ActivityType == activityType), default))
.Returns(() => ValueTask.FromResult(false));
Mock.Get(bookmarkProvider2)
.Setup(x => x.SupportsActivityAsync(It.Is <BookmarkProviderContext>(c => c.ActivityType == activityType), default))
.Returns(() => ValueTask.FromResult(true));
Mock.Get(bookmarkProvider1)
.Setup(x => x.GetBookmarksAsync(It.IsAny <BookmarkProviderContext>(), default))
.Returns(() => ValueTask.FromResult <IEnumerable <IBookmark> >(new [] { bookmark1, bookmark2 }));
Mock.Get(bookmarkProvider2)
.Setup(x => x.GetBookmarksAsync(It.IsAny <BookmarkProviderContext>(), default))
.Returns(() => ValueTask.FromResult <IEnumerable <IBookmark> >(new [] { bookmark3, bookmark4 }));
var result = await sut.GetTriggersForActivityBlueprintAsync(activityBlueprint,
workflowExecutionContext,
new Dictionary <string, ActivityType> {
{ activityType.TypeName, activityType }
});
Assert.True(result.Any(x => x.Bookmark == bookmark1), "Result contains a trigger for bookmark 1");
Assert.True(result.Any(x => x.Bookmark == bookmark2), "Result contains a trigger for bookmark 2");
Assert.True(result.Any(x => x.Bookmark == bookmark3), "Result contains a trigger for bookmark 3");
Assert.True(result.Any(x => x.Bookmark == bookmark4), "Result contains a trigger for bookmark 4");
Assert.True(result.Count() == 4, "Result has 4 items");
}
public async Task GetTriggersAsyncGetsAllTriggersForAllBlueprintsStartActivitiesAndCompatibleBookmarks([Frozen] IActivityTypeService activityTypeService,
[Frozen] ICreatesWorkflowExecutionContextForWorkflowBlueprint workflowExecutionContextFactory,
[Frozen] IGetsTriggersForActivityBlueprintAndWorkflow triggerProvider,
[Frozen] IGetsStartActivities startingActivitiesProvider,
TriggersForBlueprintsProvider sut,
IWorkflowBlueprint workflowBlueprint1,
IWorkflowBlueprint workflowBlueprint2,
ActivityType activityType1,
ActivityType activityType2,
ActivityType activityType3,
IActivityBlueprint activityBlueprint1,
IActivityBlueprint activityBlueprint2,
IActivityBlueprint activityBlueprint3,
WorkflowTrigger trigger1,
WorkflowTrigger trigger2,
WorkflowTrigger trigger3,
WorkflowTrigger trigger4,
WorkflowTrigger trigger5,
WorkflowTrigger trigger6,
[WithAutofixtureResolution] IServiceProvider serviceProvider,
[NoAutoProperties] WorkflowInstance workflowInstance)
{
Mock.Get(activityTypeService)
.Setup(x => x.GetActivityTypesAsync(default))
public void GetStartActivitiesReturnsAllActivitiesWhichHaveNoInboundConnections(GetsStartActivitiesProvider sut,
IWorkflowBlueprint workflowBlueprint,
IActivityBlueprint activityBlueprint1,
IActivityBlueprint activityBlueprint2,
IActivityBlueprint activityBlueprint3,
IActivityBlueprint activityBlueprint4,
string activityBlueprintId1,
string activityBlueprintId2,
string activityBlueprintId3,
string activityBlueprintId4,
IConnection connection1,
IConnection connection2,
ITargetEndpoint endpoint1,
ITargetEndpoint endpoint2)
{
SetupActivitiesWithIds(new () {
{ activityBlueprintId1, activityBlueprint1 },
{ activityBlueprintId2, activityBlueprint2 },
public void CreateActivityExecutionContextCreatesContextUsingBlueprintExecutionContextCancellationTokenAndServiceProvider([WithAutofixtureResolution] IServiceProvider serviceProvider,
IActivityBlueprint activityBlueprint,
[OmitOnRecursion] WorkflowExecutionContext workflowExecutionContext,
CancellationToken cancellationToken)
{
var sut = new ActivityExecutionContextForActivityBlueprintFactory(serviceProvider);
var result = sut.CreateActivityExecutionContext(activityBlueprint, workflowExecutionContext, cancellationToken);
Assert.True(ReferenceEquals(activityBlueprint, result.ActivityBlueprint), "The activity blueprint should be the same");
Assert.True(ReferenceEquals(workflowExecutionContext, result.WorkflowExecutionContext), "The workflow execution context should be the same");
Assert.True(Equals(cancellationToken, result.CancellationToken), "The cancellation token should be equal");
Assert.True(ReferenceEquals(serviceProvider, result.ServiceProvider), "The service provider should be the same");
}
public static async Task AddEntryAsync(this IWorkflowExecutionLog log, string eventName, WorkflowInstance workflowInstance, IActivityBlueprint activity, string?message, CancellationToken cancellationToken = default, [CallerLineNumber] int line = default, [CallerFilePath] string?sourceFile = default) =>
await log.AddEntryAsync(eventName, workflowInstance, activity, message, default, $"{Path.GetFileName(sourceFile)}:{line}", cancellationToken);
public void PurgeVariables_clears_workflow_execution_context_workflow_instance_variables([WithAutofixtureResolution, Frozen] IServiceProvider serviceProvider,
[OmitOnRecursion] WorkflowExecutionContext workflowExecutionContext,
IActivityBlueprint activityBlueprint,
CancellationToken cancellationToken,
string variableName,
object variableValue)
{
var sut = new ActivityExecutionContext(serviceProvider, workflowExecutionContext, activityBlueprint, null, false, cancellationToken);
sut.WorkflowExecutionContext.WorkflowInstance.Variables.Set(variableName, variableValue);
sut.PurgeVariables();
Assert.Empty(sut.WorkflowExecutionContext.WorkflowInstance.Variables.Data);
}
private async Task <RunWorkflowResult> ResumeWorkflowAsync(WorkflowExecutionContext workflowExecutionContext, IActivityBlueprint activity, CancellationToken cancellationToken)
{
try
{
if (!await CanExecuteAsync(workflowExecutionContext, activity, true, cancellationToken))
{
return(new RunWorkflowResult(workflowExecutionContext.WorkflowInstance, activity.Id, null, false));
}
var blockingActivities = workflowExecutionContext.WorkflowInstance.BlockingActivities.Where(x => x.ActivityId == activity.Id).ToList();
foreach (var blockingActivity in blockingActivities)
{
await workflowExecutionContext.RemoveBlockingActivityAsync(blockingActivity);
}
var currentStatus = workflowExecutionContext.WorkflowInstance.WorkflowStatus;
workflowExecutionContext.Resume();
workflowExecutionContext.ScheduleActivity(activity.Id);
await _mediator.Publish(new WorkflowStatusChanged(workflowExecutionContext.WorkflowInstance, workflowExecutionContext.WorkflowInstance.WorkflowStatus, currentStatus), cancellationToken);
await RunCoreAsync(workflowExecutionContext, Resume, cancellationToken);
return(new RunWorkflowResult(workflowExecutionContext.WorkflowInstance, activity.Id, null, true));
}
catch (Exception e)
{
_logger.LogWarning(e, "Failed to run workflow {WorkflowInstanceId}", workflowExecutionContext.WorkflowInstance.Id);
workflowExecutionContext.Fault(e, activity.Id, null, false);
workflowExecutionContext.AddEntry(activity, "Faulted", null, SimpleException.FromException(e));
return(new RunWorkflowResult(workflowExecutionContext.WorkflowInstance, activity.Id, e, false));
}
}
protected Endpoint(IActivityBlueprint activity)
{
Activity = activity;
}
public SourceEndpoint(IActivityBlueprint activity, string outcome) : base(activity) => Outcome = outcome;
public Connection(IActivityBlueprint sourceActivity, IActivityBlueprint targetActivity, string sourceOutcome)
: this(new SourceEndpoint(sourceActivity, sourceOutcome), new TargetEndpoint(targetActivity))
{
}
public TargetEndpoint(IActivityBlueprint activity) : base(activity)
{
}
