public WorkflowExecutorFixture()
{
//setup dependency injection
IServiceCollection services = new ServiceCollection();
services.AddLogging();
//TODO: mock these dependencies to make true unit tests
Options = new WorkflowOptions();
services.AddSingleton(Options);
services.AddTransient <IWorkflowBuilder, WorkflowBuilder>();
services.AddTransient <IWorkflowRegistry, WorkflowRegistry>();
services.AddTransient <IExecutionResultProcessor, ExecutionResultProcessor>();
services.AddTransient <IExecutionPointerFactory, ExecutionPointerFactory>();
services.AddTransient <IDateTimeProvider, DateTimeProvider>();
Host = A.Fake <IWorkflowHost>();
PersistenceProvider = A.Fake <IPersistenceProvider>();
var serviceProvider = services.BuildServiceProvider();
//config logging
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
loggerFactory.AddConsole(LogLevel.Debug);
Registry = serviceProvider.GetService <IWorkflowRegistry>();
ResultProcesser = serviceProvider.GetService <IExecutionResultProcessor>();
Subject = new WorkflowExecutor(Registry, serviceProvider, new DateTimeProvider(), ResultProcesser, Options, loggerFactory);
}
public static void DIWorkflow(IWorkflowHost host)
{
host.RegisterWorkflow <DIWorkflow>();
host.Start();
host.StartWorkflow("DIWorkflow", 1, null, null);
}
public WorkflowInstance(IWorkflowHost host, Activity workflowDefinition, WorkflowIdentity definitionIdentity)
: base(workflowDefinition, definitionIdentity)
{
this.host = host;
SynchronizationContext = new SynchronizationContext();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
// Start the workflow host
host = app.ApplicationServices.GetService <IWorkflowHost>();
host.RegisterWorkflow <ContactFormWorkflow, ContactForm>();
host.Start();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
protected virtual void Setup(bool registerClassMap = false)
{
//setup dependency injection
IServiceCollection services = new ServiceCollection();
services.AddLogging();
ConfigureServices(services);
var serviceProvider = services.BuildServiceProvider();
//config logging
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
//loggerFactory.AddConsole(LogLevel.Debug);
if (registerClassMap && !BsonClassMap.IsClassMapRegistered(typeof(TData)))
{
BsonClassMap.RegisterClassMap <TData>(map => map.AutoMap());
}
PersistenceProvider = serviceProvider.GetService <IPersistenceProvider>();
Host = serviceProvider.GetService <IWorkflowHost>();
Host.RegisterWorkflow <TWorkflow, TData>();
Host.OnStepError += Host_OnStepError;
Host.Start();
}
public static void LoopingWorkflow(IWorkflowHost host)
{
host.RegisterWorkflow <LoopingWorkflow>();
host.Start();
host.StartWorkflow("LoopingWorkflow");
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
// Start the workflow host
host = app.ApplicationServices.GetService <IWorkflowHost>();
host.RegisterWorkflow <ContactFormWorkflow, ContactForm>();
host.Start();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public WorkflowsController(IWorkflowHost workflowHost, IWorkflowRegistry registry, IPersistenceProvider workflowStore, ILoggerFactory loggerFactory)
{
_workflowHost = workflowHost;
_workflowStore = workflowStore;
_registry = registry;
_logger = loggerFactory.CreateLogger <WorkflowsController>();
}
public static void RegisterGenericWorkflow(this IWorkflowHost host, object workflow)
{
var reg = host.Registry;
var method = reg.GetType()
.GetMethods()
.Where(m => m.IsGenericMethod && m.Name == "RegisterWorkflow")
.First();
var workflowType = workflow.GetType();
var buildMethod = workflowType
.GetMethod("Build");
var buildMethodParameterType = buildMethod.GetParameters()[0].ParameterType;
var buildMethodDataType = buildMethodParameterType.GetGenericArguments()[0];
var generic = method.MakeGenericMethod(buildMethodDataType);
var invokeType = workflowType
.GetInterfaces()
.FirstOrDefault(i => i.FullName == generic.GetParameters()[0].ParameterType.FullName);
//var castMethod = workflowType.GetMethod("Cast",
// BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Instance);
//var castM = typeof(BaseWorkflow<>).GetMethods();
// Binding the method info to generic arguments
//Type[] genericArguments = new Type[] { invokeType };
//MethodInfo genericMethodInfo = castMethod.MakeGenericMethod(genericArguments);
// Simply invoking the method and passing parameters
// The null parameter is the object to call the method from. Since the method is
// static, pass null.
generic.Invoke(reg, new[] { workflow });
}
public override ExecutionPipelineDirective InitForExecution(IWorkflowHost host, IPersistenceProvider persistenceStore, WorkflowDefinition defintion, WorkflowInstance workflow, ExecutionPointer executionPointer)
{
if (!executionPointer.EventPublished)
{
//resolve principal to be assigned
var resolvedUser = Principal.Compile().DynamicInvoke(workflow.Data);
executionPointer.ExtensionAttributes["AssignedPrincipal"] = resolvedUser;
executionPointer.ExtensionAttributes["Prompt"] = UserPrompt;
Dictionary <string, object> userOptions = new Dictionary <string, object>();
foreach (var outcome in Outcomes)
{
userOptions[outcome.Label ?? Convert.ToString(outcome.Value ?? "Proceed")] = outcome.Value;
}
executionPointer.ExtensionAttributes["UserOptions"] = userOptions;
executionPointer.EventKey = workflow.Id + "." + executionPointer.Id;
executionPointer.EventName = "UserAction";
executionPointer.Active = false;
persistenceStore.PersistWorkflow(workflow).Wait();
host.SubscribeEvent(workflow.Id, executionPointer.StepId, executionPointer.EventName, executionPointer.EventKey);
return(ExecutionPipelineDirective.Defer);
}
return(ExecutionPipelineDirective.Next);
}
private async Task InvokeWorkflows(IWorkflowHost workflowHost, IEnumerable <Workflow> workflows, Uri requestPath, CancellationToken cancellationToken)
{
foreach (var workflow in workflows)
{
await InvokeWorkflowAsync(workflowHost, workflow, requestPath, cancellationToken);
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var serviceProvider = ConfigureServices();
PersistenceProvider = serviceProvider.GetRequiredService <IPersistenceProvider>();
IWorkflowHost host = serviceProvider.GetService <IWorkflowHost>();
host.RegisterWorkflow <MySagaWorkflow, MySagaData>();
//host.RegisterWorkflow<MySagaWorkflow>(); // To do withput the MySagaData class
host.Start();
var data = new MySagaData {
boo = "boo",
SpanishGreet = "¡Hola, mundo!",
EnglishGreet = "Hello, World!",
FrenchGreet = "Salut, monde!",
GermanGreet = "Hallo, Welt!",
RussianGreet = ".____.",
};
var workflowId = host.StartWorkflow <MySagaData>("PablosSagaPattern", data).Result;
// Console.ReadKey(); // This wait the user to press enter.
var remainingTime = TimeSpan.FromSeconds(5);
WaitForWorkflowToComplete(workflowId, remainingTime);
host.Stop();
}
static void Main(string[] args)
{
//Configuration
IServiceCollection services = new ServiceCollection();
services.AddLogging();
services.AddWorkflow();
//Service
IServiceProvider provider = services.BuildServiceProvider();
//Workflow get and trigger
IWorkflowHost host = provider.GetService <IWorkflowHost>();
host.RegisterWorkflow <HelloWorldWorkflow, MyData>();
host.Start();
//Start flow which by flowId
host.StartWorkflow("HelloWorld", new MyData {
Value1 = 1, Value2 = 99
});
Console.ReadKey();
host.Stop();
}
public WorkflowExecutor(IWorkflowHost host, IWorkflowRegistry registry, IServiceProvider serviceProvider, ILoggerFactory loggerFactory)
{
_host = host;
_serviceProvider = serviceProvider;
_registry = registry;
_logger = loggerFactory.CreateLogger <WorkflowExecutor>();
}
public WorkflowExecutorFixture()
{
Host = A.Fake <IWorkflowHost>();
PersistenceProvider = A.Fake <IPersistenceProvider>();
ServiceProvider = A.Fake <IServiceProvider>();
ScopeProvider = A.Fake <IScopeProvider>();
Registry = A.Fake <IWorkflowRegistry>();
ResultProcesser = A.Fake <IExecutionResultProcessor>();
EventHub = A.Fake <ILifeCycleEventPublisher>();
CancellationProcessor = A.Fake <ICancellationProcessor>();
DateTimeProvider = A.Fake <IDateTimeProvider>();
Options = new WorkflowOptions(A.Fake <IServiceCollection>());
var scope = A.Fake <IServiceScope>();
A.CallTo(() => ScopeProvider.CreateScope(A <IStepExecutionContext> ._)).Returns(scope);
A.CallTo(() => scope.ServiceProvider).Returns(ServiceProvider);
A.CallTo(() => DateTimeProvider.Now).Returns(DateTime.Now);
A.CallTo(() => DateTimeProvider.UtcNow).Returns(DateTime.UtcNow);
//config logging
var loggerFactory = new LoggerFactory();
//loggerFactory.AddConsole(LogLevel.Debug);
Subject = new WorkflowExecutor(Registry, ServiceProvider, ScopeProvider, DateTimeProvider, ResultProcesser, EventHub, CancellationProcessor, Options, loggerFactory);
}
public WorkflowExecutorFixture()
{
Host = A.Fake <IWorkflowHost>();
PersistenceProvider = A.Fake <IPersistenceProvider>();
ServiceProvider = A.Fake <IServiceProvider>();
ScopeProvider = A.Fake <IScopeProvider>();
Registry = A.Fake <IWorkflowRegistry>();
ResultProcesser = A.Fake <IExecutionResultProcessor>();
EventHub = A.Fake <ILifeCycleEventPublisher>();
CancellationProcessor = A.Fake <ICancellationProcessor>();
DateTimeProvider = A.Fake <IDateTimeProvider>();
MiddlewareRunner = A.Fake <IWorkflowMiddlewareRunner>();
StepExecutor = A.Fake <IStepExecutor>();
Options = new WorkflowOptions(A.Fake <IServiceCollection>());
var stepExecutionScope = A.Fake <IServiceScope>();
A.CallTo(() => ScopeProvider.CreateScope(A <IStepExecutionContext> ._)).Returns(stepExecutionScope);
A.CallTo(() => stepExecutionScope.ServiceProvider).Returns(ServiceProvider);
var scope = A.Fake <IServiceScope>();
var scopeFactory = A.Fake <IServiceScopeFactory>();
A.CallTo(() => ServiceProvider.GetService(typeof(IServiceScopeFactory))).Returns(scopeFactory);
A.CallTo(() => scopeFactory.CreateScope()).Returns(scope);
A.CallTo(() => scope.ServiceProvider).Returns(ServiceProvider);
A.CallTo(() => DateTimeProvider.Now).Returns(DateTime.Now);
A.CallTo(() => DateTimeProvider.UtcNow).Returns(DateTime.UtcNow);
A
.CallTo(() => ServiceProvider.GetService(typeof(IWorkflowMiddlewareRunner)))
.Returns(MiddlewareRunner);
A
.CallTo(() => ServiceProvider.GetService(typeof(IStepExecutor)))
.Returns(StepExecutor);
A.CallTo(() => MiddlewareRunner
.RunPostMiddleware(A <WorkflowInstance> ._, A <WorkflowDefinition> ._))
.Returns(Task.CompletedTask);
A.CallTo(() => MiddlewareRunner
.RunExecuteMiddleware(A <WorkflowInstance> ._, A <WorkflowDefinition> ._))
.Returns(Task.CompletedTask);
A.CallTo(() => StepExecutor.ExecuteStep(A <IStepExecutionContext> ._, A <IStepBody> ._))
.ReturnsLazily(call =>
call.Arguments[1].As <IStepBody>().RunAsync(
call.Arguments[0].As <IStepExecutionContext>()));
//config logging
var loggerFactory = new LoggerFactory();
//loggerFactory.AddConsole(LogLevel.Debug);
Subject = new WorkflowExecutor(Registry, ServiceProvider, ScopeProvider, DateTimeProvider, ResultProcesser, EventHub, CancellationProcessor, Options, loggerFactory);
}
public DashboardController(ILogger <DashboardController> logger, IWorkflowRegistry registry,
IPersistenceProvider workflowStore, IWorkflowHost workflowHost)
{
_workflowHost = workflowHost;
_workflowStore = workflowStore;
_registry = registry;
_logger = logger;
}
public WorkflowService(
RenderOptions options,
IWorkflowHost host)
{
_options = options;
_host = host;
_resetEvent = new AutoResetEvent(false);
}
public static void CheckStatement(IWorkflowHost host)
{
host.RegisterWorkflow <CheckWorkflow, CheckData>();
host.Start();
Console.WriteLine("Starting Check...");
string workflowId = host.StartWorkflow("check").Result;
}
public RegistryController(IWorkflowHost workflowHost, IWorkflowRegistry registry, IWorkflowController controller, IDefinitionLoader loader, IPersistenceProvider workflowStore, ILoggerFactory loggerFactory)
{
_workflowHost = workflowHost;
_workflowStore = workflowStore;
_registry = registry;
_logger = loggerFactory.CreateLogger <WorkflowController>();
_controller = controller;
_loader = loader;
}
public SyncWorkflowRunner(IWorkflowHost host, IWorkflowExecutor executor, IDistributedLockProvider lockService, IWorkflowRegistry registry, IPersistenceProvider persistenceStore, IExecutionPointerFactory pointerFactory, IQueueProvider queueService)
{
_host = host;
_executor = executor;
_lockService = lockService;
_registry = registry;
_persistenceStore = persistenceStore;
_pointerFactory = pointerFactory;
_queueService = queueService;
}
public AppHostedService(ILogger <AppHostedService> logger,
IWorkflowController workflowController,
IWorkflowRegistry workflowRegistry,
IWorkflowHost workHost)
{
_logger = logger;
_workflowController = workflowController;
_workflowRegistry = workflowRegistry;
_workHost = workHost;
}
public SyncService(
IWorkflowHost host,
IEnumerable <IBaseWorkflow> workflows,
WorkingSchedules workingSchedules)
{
_ranWorkflows = new List <string>();
_host = host;
this.workflows = workflows;
this.workingSchedules = workingSchedules;
}
public static async Task PublishUserAction(this IWorkflowHost host, string actionKey, string user, object value)
{
UserAction data = new UserAction
{
User = user,
OutcomeValue = value
};
await host.PublishEvent(UserTask.EventName, actionKey, data);
}
public WorkflowCore(IWorkflowRegistry registry, IPersistenceProvider persistenceProvider, IServiceProvider serviceProvider, IOptions <Workflows.Workflows> workflows)
{
_serviceProvider = serviceProvider;
_host = serviceProvider.GetService <IWorkflowHost>();
_registry = registry;
_workflowStore = persistenceProvider;
_loader = serviceProvider.GetService <IDefinitionLoader>();
_workflows = workflows.Value;
_host.Start();
this.RegisterWorkflow();
}
private async Task InvokeWorkflowAsync(IWorkflowHost workflowHost, Workflow workflow, Uri requestPath, CancellationToken cancellationToken)
{
if (workflow.Status == WorkflowStatus.Idle)
{
await StartHttpWorkflowAsync(workflowHost, workflow, requestPath, cancellationToken);
}
else if (workflow.Status == WorkflowStatus.Halted)
{
await ResumeHttpWorkflowAsync(workflowHost, workflow, requestPath, cancellationToken);
}
}
public static void WhileLoop(IWorkflowHost host)
{
host.RegisterWorkflow <WhileWorkflow, WhileLoop.MyData>();
host.Start();
Console.WriteLine("Starting workflow...");
string workflowId = host.StartWorkflow("While", new WhileLoop.MyData()
{
Counter = 0
}).Result;
}
public override ExecutionPipelineDirective BeforeExecute(IWorkflowHost host, IPersistenceProvider persistenceStore, IStepExecutionContext context, ExecutionPointer executionPointer, IStepBody body)
{
if (executionPointer.EventPublished)
{
if (body is ISubscriptionBody)
{
(body as ISubscriptionBody).EventData = executionPointer.EventData;
}
}
return(ExecutionPipelineDirective.Next);
}
public static void ParallelTask(IWorkflowHost host)
{
host.RegisterWorkflow <ParallelWorkflow, ParallelTask.MyData>();
host.Start();
Console.WriteLine("Starting workflow...");
string workflowId = host.StartWorkflow("parallel-sample", new ParallelTask.MyData()
{
Counter = 4
}).Result;
}
public static void MutipleOutcome(IWorkflowHost host)
{
host.RegisterWorkflow <OutcomeWorkflow, MutipleOutcomes.MyData>();
host.Start();
Console.WriteLine("Starting workflow...");
host.StartWorkflow("outcome-sample", new MutipleOutcomes.MyData()
{
Value = 2
});
}
