How to return early from a workflow?

[weirdyang]

How can we return an immediate HTTP response when triggering long-running workflows, so the caller doesn't have to wait for workflow completion?

We have tried to use fork, but the workflow still waits for the delay to complete before returning the response:

[lampersky]

you can emit signal and return response in one workflow, another workflow can react to signal and perform long-running task

you can find an example here

[weirdyang]

I have tried that, one path waits for the signal, the other triggers the url with a http request task. The http request gets a 404 not found response.

Edit; sorry I'm trying to use one workflow.

[weirdyang]

We have also tried this too, but we're trying not to wait for a minute, thanks anyway, looks like I'll need to build a custom workflow event.

[weirdyang]

My solution:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Localization;
using Microsoft.Extensions.Logging;
using OrchardCore.BackgroundJobs;
using OrchardCore.Modules;
using OrchardCore.Workflows.Abstractions.Models;
using OrchardCore.Workflows.Activities;
using OrchardCore.Workflows.Display;
using OrchardCore.Workflows.Helpers;
using OrchardCore.Workflows.Models;
using OrchardCore.Workflows.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace OrchardCore.ReturnEarly
{
    public class ReturnEarlyConstants
    {
        public const string Name = "OrchardCore.ReturnEarly";
    }
    [Feature(ReturnEarlyConstants.Name)]
    public class ReturnEarlyStartup : StartupBase
    {
        public override void ConfigureServices(IServiceCollection services)
        {
            services.AddActivity<ReturnEarlyEvent, ReturnEarlyEventDisplay>();
            services.AddScoped<IWorkflowManager, OrchardCore.Workflows.Replacement.WorkflowManager>();
        }
    }
    public class ReturnEarlyEventViewModel
    {
    }
    public class ReturnEarlyEventDisplay : ActivityDisplayDriver<ReturnEarlyEvent, ReturnEarlyEventViewModel>
    {
        protected override void EditActivity(ReturnEarlyEvent source, ReturnEarlyEventViewModel model)
        {

        }

        protected override void UpdateActivity(ReturnEarlyEventViewModel model, ReturnEarlyEvent target)
        {

        }
    }
    public class ReturnEarlyEvent : Activity, IEvent
    {
        public static string EventName => nameof(ReturnEarlyEvent);

        public ReturnEarlyEvent(IStringLocalizer<ReturnEarlyEvent> localizer)
        {
            T = localizer;
        }

        private IStringLocalizer T { get; }

        public override string Name => EventName;
        public override LocalizedString DisplayText => T["Return Early Event"];

        public override LocalizedString Category => T["Background"];

        public override async Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityContext activityContext)
        {
            await HttpBackgroundJob.ExecuteAfterEndOfRequestAsync("trigger-event", async scope =>
            {
                IWorkflowManager workflowManager = scope.ServiceProvider.GetRequiredService<IWorkflowManager>();
                var logger = scope.ServiceProvider.GetRequiredService<ILogger<ReturnEarlyEvent>>();
                logger.LogDebug("Triggering {event}", EventName);
                var contexts = await workflowManager.TriggerEventAsync(EventName, null, null, isExclusive: true, isAlwaysCorrelated: true);
                logger.LogDebug("Triggered {number} workflows: {@workflows}", contexts.Count(), contexts);
            });
            return Halt();
        }
        public override async Task<bool> CanExecuteAsync(WorkflowExecutionContext workflowContext, ActivityContext activityContext)
        {

            return true;
        }

        public override IEnumerable<Outcome> GetPossibleOutcomes(WorkflowExecutionContext workflowContext, ActivityContext activityContext)
        {
            return Outcomes(T["Done"]);
        }

        public override ActivityExecutionResult Resume(WorkflowExecutionContext workflowContext, ActivityContext activityContext)
        {
            return Outcomes("Done");
        }

    }
}