Fire-and-Forget Workflow - Am I doing this wrong?

[DavidPx]

I'm mocking up a workflow which on average will run for a few minutes mostly doing background SQL operations. It will be invoked from an API whose client will get the WorkflowInstanceId in order that they can periodically check up on the work.

The problem I'm having is that the IBuildsAndStartsWorkflow.BuildAndStartWorkflowAsync method only returns once the workflow is completed... I expected it to simply kick it off in the background. Am I doing something wrong? Code is below.

I'm working with the latest 2.0 preview packages from MyGet.

Here is my workflow:

    public class VerySlowWorkflow : IWorkflow
    {
        public void Build(IWorkflowBuilder builder)
        {
            builder
                .WithWorkflowDefinitionId(nameof(VerySlowWorkflow))
                .WithVersion(1)
                .StartWith(x =>
                {
                    Trace.WriteLine("Starting the very slow workflow");

                })
                .Then(async x =>
                {
                    Trace.WriteLine("Delaying for 5 seconds...");
                    await Task.Delay(new TimeSpan(0, 0, 5));
                    Trace.WriteLine("Done with delay!");
                })
                .Then(async x =>
                {
                    Trace.WriteLine("Delaying for 5 seconds...");
                    await Task.Delay(new TimeSpan(0, 0, 5));
                    Trace.WriteLine("Done with delay!");
                })
                .Then(x =>
                {
                    Trace.WriteLine("All done!");
                });
                ;
        }
    }

And the invoking controller:

        [HttpPost]
        public async Task<IActionResult> Start()
        {
            var instance = await _runner.BuildAndStartWorkflowAsync<VerySlowWorkflow>();

            return Ok(new
            {
                WorkflowInstanceId = instance.Id
            });
        }

Thanks!

[sfmskywalker]

Currently, Elsa has two ways to execute workflows: the "core" API runs the workflow synchronously (i.e. not in the background). The other way is to run it from a background worker. To run a workflow from a background worker, you need to "dispatch" a workflow using IWorkflowDefinitionDispatcher, which means nothing more than sending a message or enqueueing a job, depending on which dispatch provider is installed.

By default, the QueueingWorkflowDispatcher is installed (in the DI service container), but when executing workflows that might take minutes to complete (while being in-memory), a better dispatcher might be the HangfireWorkflowDispatcher. That one enqueues a Hangfire job, which can take as much time as you want without Hangfire trying to re-execute the job, unlike typical message brokers such as Azure Service Bus and RabbitMQ.

There's also an Orleans dispatcher, but contrary to what I originally assumed, that one does not cause the workflow to be executed in the background. Which is one of the reasons I'm thinking about a small redesign of the way workflows get processed at the moment.

Anyway, if you inject IWorkflowDefinitionDispatcher you can use its DispatchAsync to run workflow definitions without having to wait for them to complete.

There is also IWorkflowInstanceDispatcher and IWorkflowDispatcher to resume workflow instances and trigger new & existing workflows respectively. The latter is useful when you simply have an event that should trigger new workflows and resume existing ones depending on whether they start with or are blocked on a given activity type.

[DavidPx]

Thank you for the detailed response, Sipke! It's much appreciated.

[DavidPx]

Here is my controller code in case it helps out anyone else:

public class SlowController : ControllerBase
    {
        private readonly IWorkflowInstanceStore _workflowInstanceStore;
        private readonly IWorkflowDefinitionDispatcher _dispatcher;

        public SlowController(IWorkflowInstanceStore workflowInstanceStore, IWorkflowDefinitionDispatcher dispatcher)
        {
            _workflowInstanceStore = workflowInstanceStore;
            _dispatcher = dispatcher;
        }
        [HttpPost]
        public async Task<IActionResult> Start()
        {
            var correlationId = Guid.NewGuid().ToString();

            await _dispatcher.DispatchAsync(
                new ExecuteWorkflowDefinitionRequest(
                    VerySlowWorkflow.VerySlowWorkflowDefinitionId, 
                    CorrelationId: correlationId));

            return Ok(new
            {
                CorrelationId = correlationId
            });
        }

        public async Task<IActionResult> Get(string correlationId)
        {
            var instance = await _workflowInstanceStore.FindByCorrelationIdAsync(correlationId);
             
            if (instance == null) return NotFound();

            return Ok(new
            {
                WorkflowInstanceId = instance.Id,
                instance.WorkflowStatus,
                CreatedAt = instance.CreatedAt.ToDateTimeOffset(),
                LastExecutedAt = instance.LastExecutedAt?.ToDateTimeOffset() ?? DateTimeOffset.MinValue,
                CurrentActivity = instance.CurrentActivity == null ? "" : instance.CurrentActivity.ActivityId
            });
        }
    }

[sfmskywalker]

Nice. Thanks for sharing!