Distributed locks to prevent multiple pods executing Reload and Refresh

src/modules/Elsa.Workflows.Api/Endpoints/WorkflowDefinitions/Refresh/Endpoint.cs

@@ -20,7 +20,14 @@ public override void Configure()
     public override async Task HandleAsync(Request request, CancellationToken cancellationToken)
     {
         var result = await RefreshWorkflowDefinitionsAsync(request.DefinitionIds, cancellationToken);
-        await Send.OkAsync(new Response(result.Refreshed, result.NotFound), cancellationToken);
+        if (result.Status == RefreshWorkflowDefinitionsStatus.Completed)
+        {
+            await Send.OkAsync(new Response(result.Refreshed, result.NotFound), cancellationToken);
+        }
+        else
+        {
+            await Send.AcceptedAtAsync<Refresh>(responseBody: new Response(result.Refreshed, result.NotFound), cancellation: cancellationToken);
+        }
     }
 
     private async Task<RefreshWorkflowDefinitionsResponse> RefreshWorkflowDefinitionsAsync(ICollection<string>? definitionIds, CancellationToken cancellationToken)

src/modules/Elsa.Workflows.Runtime.Distributed/Features/DistributedRuntimeFeature.cs

@@ -29,6 +29,9 @@ public override void Apply()
     {
         Services
             .AddScoped<DistributedWorkflowRuntime>()
-            .AddScoped<DistributedBookmarkQueueWorker>();
+            .AddScoped<DistributedBookmarkQueueWorker>()
+
+            .Decorate<IWorkflowDefinitionsRefresher, DistributedWorkflowDefinitionsRefresher>()
+            .Decorate<IWorkflowDefinitionsReloader, DistributedWorkflowDefinitionsReloader>();
     }
 }

src/modules/Elsa.Workflows.Runtime.Distributed/Services/DistributedWorkflowDefinitionsRefresher.cs

@@ -0,0 +1,46 @@
+using Elsa.Workflows.Runtime.Requests;
+using Elsa.Workflows.Runtime.Responses;
+using JetBrains.Annotations;
+using Medallion.Threading;
+using Microsoft.Extensions.Logging;
+
+namespace Elsa.Workflows.Runtime.Distributed;
+
+/// <summary>
+/// Decorator class that adds distributed locking to the Workflow Definitions Refresher.
+/// </summary>
+[UsedImplicitly]
+public class DistributedWorkflowDefinitionsRefresher(IWorkflowDefinitionsRefresher inner,
+    IDistributedLockProvider distributedLockProvider,
+    ILogger<DistributedWorkflowDefinitionsRefresher> logger) : IWorkflowDefinitionsRefresher
+{
+    /// <summary>
+    /// This ensures that only one instance of the application can refresh a set of workflow definitions at a time, preventing potential conflicts and ensuring consistency across distributed environments.
+    /// </summary>
+    public async Task<RefreshWorkflowDefinitionsResponse> RefreshWorkflowDefinitionsAsync(RefreshWorkflowDefinitionsRequest request, CancellationToken cancellationToken = default)
+    {
+        var isRefreshingAll = request.DefinitionIds == null || request.DefinitionIds.Count == 0;
+        var lockKey = isRefreshingAll
+            ? "WorkflowDefinitionsRefresher:All"
+            : $"WorkflowDefinitionsRefresher:{string.Join(",", request.DefinitionIds!.OrderBy(x => x))}";
+
+        await using var distributedLock = await distributedLockProvider.TryAcquireLockAsync(
+            lockKey,
+            TimeSpan.Zero,
+            cancellationToken);
+
+        if (distributedLock == null)
+        {
+            var logMessage = isRefreshingAll
+                ? "Could not acquire lock for refreshing all workflow definitions. Another instance is already refreshing all workflow definitions"
+                : "Could not acquire lock for refreshing workflow definitions. Another instance is already refreshing these workflow definitions";
+
+            logger.LogInformation(logMessage);
+
+            var failedDefinitionIds = isRefreshingAll ? Array.Empty<string>() : request.DefinitionIds!;
+            return new(Array.Empty<string>(), failedDefinitionIds, RefreshWorkflowDefinitionsStatus.AlreadyInProgress);
+        }
+
+        return await inner.RefreshWorkflowDefinitionsAsync(request, cancellationToken);
+    }
+}

src/modules/Elsa.Workflows.Runtime.Distributed/Services/DistributedWorkflowDefinitionsReloader.cs

@@ -0,0 +1,36 @@
+using JetBrains.Annotations;
+using Medallion.Threading;
+using Microsoft.Extensions.Logging;
+
+namespace Elsa.Workflows.Runtime.Distributed;
+
+/// <summary>
+/// Decorator class that adds distributed locking to the Workflow Definitions Reloader.
+/// </summary>
+[UsedImplicitly]
+public class DistributedWorkflowDefinitionsReloader(
+    IWorkflowDefinitionsReloader inner,
+    IDistributedLockProvider distributedLockProvider,
+    ILogger<DistributedWorkflowDefinitionsReloader> logger) : IWorkflowDefinitionsReloader
+{
+    private const string LockKey = "WorkflowDefinitionsReloader";
+
+    /// <summary>
+    /// This ensures that only one instance of the application can reload workflow definitions at a time, preventing potential conflicts and ensuring consistency across distributed environments.
+    /// </summary>
+    public async Task ReloadWorkflowDefinitionsAsync(CancellationToken cancellationToken = default)
+    {
+        await using var distributedLock = await distributedLockProvider.TryAcquireLockAsync(
+            LockKey,
+            TimeSpan.Zero,
+            cancellationToken);
+
+        if (distributedLock == null)
+        {
+            logger.LogInformation("Could not acquire lock for workflow definitions reload. Another instance is already reloading workflow definitions");
+            return;
+        }
+
+        await inner.ReloadWorkflowDefinitionsAsync(cancellationToken);
+    }
+}

src/modules/Elsa.Workflows.Runtime/Enums/RefreshWorkflowDefinitionsStatus.cs

@@ -0,0 +1,7 @@
+namespace Elsa.Workflows.Runtime;
+
+public enum RefreshWorkflowDefinitionsStatus
+{
+    Completed,
+    AlreadyInProgress
+}

src/modules/Elsa.Workflows.Runtime/Responses/RefreshWorkflowDefinitionsResponse.cs

@@ -3,4 +3,8 @@ namespace Elsa.Workflows.Runtime.Responses;
 /// <summary>
 /// Represents a response to a request to refresh workflow definitions.
 /// </summary>
-public record RefreshWorkflowDefinitionsResponse(ICollection<string> Refreshed, ICollection<string> NotFound);
+public record RefreshWorkflowDefinitionsResponse(
+    ICollection<string> Refreshed,
+    ICollection<string> NotFound,
+    RefreshWorkflowDefinitionsStatus Status = RefreshWorkflowDefinitionsStatus.Completed
+    );