예제 #1
0
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            var activity = WorkflowActivity.StartHost();

            try
            {
                _shutdown = false;
                PersistenceStore.EnsureStoreExists();
                await QueueProvider.Start();

                await LockProvider.Start();

                await _lifeCycleEventHub.Start();

                await _searchIndex.Start();

                // Event subscriptions are removed when stopping the event hub.
                // Add them when starting.
                AddEventSubscriptions();

                Logger.LogInformation("Starting background tasks");

                foreach (var task in _backgroundTasks)
                {
                    task.Start();
                }
            }
            catch (Exception ex)
            {
                activity.RecordException(ex);
                throw;
            }
            finally
            {
                activity?.Dispose();
            }
        }
예제 #2
0
        public async Task <WorkflowExecutorResult> Execute(WorkflowInstance workflow, CancellationToken cancellationToken = default)
        {
            var wfResult = new WorkflowExecutorResult();

            var exePointers = new List <ExecutionPointer>(workflow.ExecutionPointers.Where(x => x.Active && (!x.SleepUntil.HasValue || x.SleepUntil < _datetimeProvider.UtcNow)));
            var def         = _registry.GetDefinition(workflow.WorkflowDefinitionId, workflow.Version);

            if (def == null)
            {
                _logger.LogError("Workflow {0} version {1} is not registered", workflow.WorkflowDefinitionId, workflow.Version);
                return(wfResult);
            }

            _cancellationProcessor.ProcessCancellations(workflow, def, wfResult);

            foreach (var pointer in exePointers)
            {
                if (!pointer.Active)
                {
                    continue;
                }

                var step = def.Steps.FindById(pointer.StepId);
                if (step == null)
                {
                    _logger.LogError("Unable to find step {0} in workflow definition", pointer.StepId);
                    pointer.SleepUntil = _datetimeProvider.UtcNow.Add(_options.ErrorRetryInterval);
                    wfResult.Errors.Add(new ExecutionError
                    {
                        WorkflowId         = workflow.Id,
                        ExecutionPointerId = pointer.Id,
                        ErrorTime          = _datetimeProvider.UtcNow,
                        Message            = $"Unable to find step {pointer.StepId} in workflow definition"
                    });
                    continue;
                }

                WorkflowActivity.Enrich(step);
                try
                {
                    if (!InitializeStep(workflow, step, wfResult, def, pointer))
                    {
                        continue;
                    }

                    await ExecuteStep(workflow, step, pointer, wfResult, def, cancellationToken);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Workflow {0} raised error on step {1} Message: {2}", workflow.Id, pointer.StepId, ex.Message);
                    wfResult.Errors.Add(new ExecutionError
                    {
                        WorkflowId         = workflow.Id,
                        ExecutionPointerId = pointer.Id,
                        ErrorTime          = _datetimeProvider.UtcNow,
                        Message            = ex.Message
                    });

                    _executionResultProcessor.HandleStepException(workflow, def, pointer, step, ex);
                    Host.ReportStepError(workflow, step, ex);
                }
                _cancellationProcessor.ProcessCancellations(workflow, def, wfResult);
            }
            ProcessAfterExecutionIteration(workflow, def, wfResult);
            await DetermineNextExecutionTime(workflow, def);

            using (var scope = _serviceProvider.CreateScope())
            {
                var middlewareRunner = scope.ServiceProvider.GetRequiredService <IWorkflowMiddlewareRunner>();
                await middlewareRunner.RunExecuteMiddleware(workflow, def);
            }

            return(wfResult);
        }