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 }); }