Abstract submit and poll operations (#19688)

* Started implementing new LongRunningOperationService and adjusting tasks to use this service

This service will manage operations that require status to be synced between servers (load balanced setup).

* Missing migration to add new lock. Other simplifications.

* Add job to cleanup the LongRunningOperations entries

* Add new DatabaseCacheRebuilder.RebuildAsync method

This is both async and returns an attempt, which will fail if a rebuild operation is already running.

* Missing LongRunningOperation database table creation on clean install

* Store expire date in the long running operation. Better handling of non-background operations.

Storing an expiration date allows setting different expiration times depending on the type of operation, and whether it is running in the background or not.

* Added integration tests for LongRunningOperationRepository

* Added unit tests for LongRunningOperationService

* Add type as a parameter to more repository calls. Distinguish between expiration and deletion in `LongRunningOperationRepository.CleanOperations`.

* Fix failing unit test

* Fixed `PerformPublishBranchAsync` result not being deserialized correctly

* Remove unnecessary DatabaseCacheRebuildResult value

* Add status to `LongRunningOperationService.GetResult` attempt to inform on why a result could not be retrieved

* General improvements

* Missing rename

* Improve the handling of long running operations that are not in background and stale operations

* Fix failing unit tests

* Fixed small mismatch between interface and implementation

* Use a fire and forget task instead of the background queue

* Apply suggestions from code review

Co-authored-by: Andy Butland <abutland73@gmail.com>

* Make sure exceptions are caught when running in the background

* Alignment with other repositories (async + pagination)

* Additional fixes

* Add Async suffix to service methods

* Missing adjustment

* Moved hardcoded settings to IOptions

* Fix issue in SQL Server where 0 is not accepted as requested number of rows

* Fix issue in SQL Server where query provided to count cannot contain orderby

* Additional SQL Server fixes

---------

Co-authored-by: Andy Butland <abutland73@gmail.com>

Author: lauraneto

src/Umbraco.Cms.Api.Management/Controllers/Document/PublishDocumentWithDescendantsController.cs

@@ -58,11 +58,12 @@ public async Task<IActionResult> PublishWithDescendants(CancellationToken cancel
             true);
 
         return attempt.Success && attempt.Result.AcceptedTaskId.HasValue
-            ? Ok(new PublishWithDescendantsResultModel
-            {
-                TaskId = attempt.Result.AcceptedTaskId.Value,
-                IsComplete = false
-            })
+            ? Ok(
+                new PublishWithDescendantsResultModel
+                {
+                    TaskId = attempt.Result.AcceptedTaskId.Value,
+                    IsComplete = false,
+                })
             : DocumentPublishingOperationStatusResult(attempt.Status, failedBranchItems: attempt.Result.FailedItems);
     }
 

src/Umbraco.Cms.Api.Management/Controllers/Document/PublishDocumentWithDescendantsResultController.cs

@@ -49,21 +49,23 @@ public async Task<IActionResult> PublishWithDescendantsResult(CancellationToken
         var isPublishing = await _contentPublishingService.IsPublishingBranchAsync(taskId);
         if (isPublishing)
         {
-            return Ok(new PublishWithDescendantsResultModel
-            {
-                TaskId = taskId,
-                IsComplete = false
-            });
-        };
+            return Ok(
+                new PublishWithDescendantsResultModel
+                {
+                    TaskId = taskId,
+                    IsComplete = false,
+                });
+        }
 
         // If completed, get the result and return the status.
         Attempt<ContentPublishingBranchResult, ContentPublishingOperationStatus> attempt = await _contentPublishingService.GetPublishBranchResultAsync(taskId);
         return attempt.Success
-            ? Ok(new PublishWithDescendantsResultModel
-            {
-                TaskId = taskId,
-                IsComplete = true
-            })
+            ? Ok(
+                new PublishWithDescendantsResultModel
+                {
+                    TaskId = taskId,
+                    IsComplete = true,
+                })
             : DocumentPublishingOperationStatusResult(attempt.Status, failedBranchItems: attempt.Result.FailedItems);
     }
 }

src/Umbraco.Cms.Api.Management/Controllers/PublishedCache/RebuildPublishedCacheController.cs

@@ -1,6 +1,8 @@
 using Asp.Versioning;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.PublishedCache;
 
 namespace Umbraco.Cms.Api.Management.Controllers.PublishedCache;
@@ -15,9 +17,10 @@ public class RebuildPublishedCacheController : PublishedCacheControllerBase
     [HttpPost("rebuild")]
     [MapToApiVersion("1.0")]
     [ProducesResponseType(StatusCodes.Status200OK)]
-    public Task<IActionResult> Rebuild(CancellationToken cancellationToken)
+    public async Task<IActionResult> Rebuild(CancellationToken cancellationToken)
     {
-        if (_databaseCacheRebuilder.IsRebuilding())
+        Attempt<DatabaseCacheRebuildResult> attempt = await _databaseCacheRebuilder.RebuildAsync(true);
+        if (attempt is { Success: false, Result: DatabaseCacheRebuildResult.AlreadyRunning })
         {
             var problemDetails = new ProblemDetails
             {
@@ -26,11 +29,9 @@ public Task<IActionResult> Rebuild(CancellationToken cancellationToken)
                 Status = StatusCodes.Status400BadRequest,
                 Type = "Error",
             };
-
-            return Task.FromResult<IActionResult>(Conflict(problemDetails));
+            return Conflict(problemDetails);
         }
 
-        _databaseCacheRebuilder.Rebuild(true);
-        return Task.FromResult<IActionResult>(Ok());
+        return Ok();
     }
 }

src/Umbraco.Cms.Api.Management/Controllers/PublishedCache/RebuildPublishedCacheStatusController.cs

@@ -16,12 +16,13 @@ public class RebuildPublishedCacheStatusController : PublishedCacheControllerBas
     [HttpGet("rebuild/status")]
     [MapToApiVersion("1.0")]
     [ProducesResponseType(typeof(RebuildStatusModel), StatusCodes.Status200OK)]
-    public Task<IActionResult> Status(CancellationToken cancellationToken)
+    public async Task<IActionResult> Status(CancellationToken cancellationToken)
     {
-        var isRebuilding = _databaseCacheRebuilder.IsRebuilding();
-        return Task.FromResult((IActionResult)Ok(new RebuildStatusModel
-        {
-            IsRebuilding = isRebuilding
-        }));
+        var isRebuilding = await _databaseCacheRebuilder.IsRebuildingAsync();
+        return Ok(
+            new RebuildStatusModel
+            {
+                IsRebuilding = isRebuilding,
+            });
     }
 }

src/Umbraco.Core/AttemptOfTResultTStatus.cs

@@ -1,3 +1,5 @@
+using System.Text.Json.Serialization;
+
 namespace Umbraco.Cms.Core;
 
 /// <summary>
@@ -9,6 +11,7 @@ namespace Umbraco.Cms.Core;
 public struct Attempt<TResult, TStatus>
 {
     // private - use Succeed() or Fail() methods to create attempts
+    [JsonConstructor]
     private Attempt(bool success, TResult result, TStatus status, Exception? exception)
     {
         Success = success;

src/Umbraco.Core/Configuration/Models/LongRunningOperationsCleanupSettings.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using System.ComponentModel;
+
+namespace Umbraco.Cms.Core.Configuration.Models;
+
+/// <summary>
+///     Typed configuration options for long-running operations cleanup settings.
+/// </summary>
+public class LongRunningOperationsCleanupSettings
+{
+    private const string StaticPeriod = "00:02:00";
+    private const string StaticMaxAge = "01:00:00";
+
+    /// <summary>
+    /// Gets or sets a value for the period in which long-running operations are cleaned up.
+    /// </summary>
+    [DefaultValue(StaticPeriod)]
+    public TimeSpan Period { get; set; } = TimeSpan.Parse(StaticPeriod);
+
+    /// <summary>
+    /// Gets or sets the maximum time a long-running operation entry can exist, without being updated, before it is considered for cleanup.
+    /// </summary>
+    [DefaultValue(StaticMaxAge)]
+    public TimeSpan MaxEntryAge { get; set; } = TimeSpan.Parse(StaticMaxAge);
+}

src/Umbraco.Core/Configuration/Models/LongRunningOperationsSettings.cs

@@ -0,0 +1,33 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using System.ComponentModel;
+
+namespace Umbraco.Cms.Core.Configuration.Models;
+
+/// <summary>
+///     Typed configuration options for long-running operations settings.
+/// </summary>
+[UmbracoOptions(Constants.Configuration.ConfigLongRunningOperations)]
+public class LongRunningOperationsSettings
+{
+    private const string StaticExpirationTime = "00:05:00";
+    private const string StaticTimeBetweenStatusChecks = "00:00:10";
+
+    /// <summary>
+    /// Gets or sets the cleanup settings for long-running operations.
+    /// </summary>
+    public LongRunningOperationsCleanupSettings Cleanup { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets the time after which a long-running operation is considered expired/stale, if not updated.
+    /// </summary>
+    [DefaultValue(StaticExpirationTime)]
+    public TimeSpan ExpirationTime { get; set; } = TimeSpan.Parse(StaticExpirationTime);
+
+    /// <summary>
+    /// Gets or sets the time between status checks for long-running operations.
+    /// </summary>
+    [DefaultValue(StaticTimeBetweenStatusChecks)]
+    public TimeSpan TimeBetweenStatusChecks { get; set; } = TimeSpan.Parse(StaticTimeBetweenStatusChecks);
+}

src/Umbraco.Core/Constants-Configuration.cs

@@ -40,6 +40,7 @@ public static class Configuration
         public const string ConfigExamine = ConfigPrefix + "Examine";
         public const string ConfigIndexing = ConfigPrefix + "Indexing";
         public const string ConfigLogging = ConfigPrefix + "Logging";
+        public const string ConfigLongRunningOperations = ConfigPrefix + "LongRunningOperations";
         public const string ConfigMemberPassword = ConfigPrefix + "Security:MemberPassword";
         public const string ConfigModelsBuilder = ConfigPrefix + "ModelsBuilder";
         public const string ConfigModelsMode = ConfigModelsBuilder + ":ModelsMode";

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Configuration.cs

@@ -69,6 +69,7 @@ public static IUmbracoBuilder AddConfiguration(this IUmbracoBuilder builder)
             .AddUmbracoOptions<ImagingSettings>()
             .AddUmbracoOptions<IndexingSettings>()
             .AddUmbracoOptions<LoggingSettings>()
+            .AddUmbracoOptions<LongRunningOperationsSettings>()
             .AddUmbracoOptions<MemberPasswordConfigurationSettings>()
             .AddUmbracoOptions<NuCacheSettings>()
             .AddUmbracoOptions<RequestHandlerSettings>()

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs

@@ -34,6 +34,7 @@
 using Umbraco.Cms.Core.Security;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Services.ContentTypeEditing;
+using Umbraco.Cms.Core.HostedServices;
 using Umbraco.Cms.Core.Preview;
 using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.PublishedCache.Internal;
@@ -341,6 +342,7 @@ private void AddCoreServices()
             Services.AddUnique<ILocalizedTextService>(factory => new LocalizedTextService(
                 factory.GetRequiredService<Lazy<LocalizedTextServiceFileSources>>(),
                 factory.GetRequiredService<ILogger<LocalizedTextService>>()));
+            Services.AddUnique<ILongRunningOperationService, LongRunningOperationService>();
 
             Services.AddUnique<IEntityXmlSerializer, EntityXmlSerializer>();