Abstract submit and poll operations

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 @@
             Services.AddUnique<ILocalizedTextService>(factory => new LocalizedTextService(
                 factory.GetRequiredService<Lazy<LocalizedTextServiceFileSources>>(),
                 factory.GetRequiredService<ILogger<LocalizedTextService>>()));
+            Services.AddUnique<ILongRunningOperationService, LongRunningOperationService>();
 
             Services.AddUnique<IEntityXmlSerializer, EntityXmlSerializer>();
 

src/Umbraco.Core/Models/ContentPublishing/ContentPublishingBranchInternalResult.cs

@@ -0,0 +1,14 @@
+namespace Umbraco.Cms.Core.Models.ContentPublishing;
+
+internal sealed class ContentPublishingBranchInternalResult
+{
+    public Guid? ContentKey { get; init; }
+
+    public IContent? Content { get; init; }
+
+    public IEnumerable<ContentPublishingBranchItemResult> SucceededItems { get; set; } = [];
+
+    public IEnumerable<ContentPublishingBranchItemResult> FailedItems { get; set; } = [];
+
+    public Guid? AcceptedTaskId { get; init; }
+}

src/Umbraco.Core/Models/DatabaseCacheRebuildResult.cs

@@ -0,0 +1,17 @@
+namespace Umbraco.Cms.Core.Models;
+
+/// <summary>
+/// Represents the result of a database cache rebuild operation.
+/// </summary>
+public enum DatabaseCacheRebuildResult
+{
+    /// <summary>
+    /// The cache rebuild operation was either successful or enqueued successfully.
+    /// </summary>
+    Success,
+
+    /// <summary>
+    /// A cache rebuild operation is already in progress.
+    /// </summary>
+    AlreadyRunning,
+}

src/Umbraco.Core/Models/LongRunningOperation.cs

@@ -0,0 +1,22 @@
+namespace Umbraco.Cms.Core.Models;
+
+/// <summary>
+/// Represents a long-running operation.
+/// </summary>
+public class LongRunningOperation
+{
+    /// <summary>
+    /// Gets the unique identifier for the long-running operation.
+    /// </summary>
+    public required Guid Id { get; init; }
+
+    /// <summary>
+    /// Gets or sets the type of the long-running operation.
+    /// </summary>
+    public required string Type { get; set; }
+
+    /// <summary>
+    /// Gets or sets the status of the long-running operation.
+    /// </summary>
+    public required LongRunningOperationStatus Status { get; set; }
+}

src/Umbraco.Core/Models/LongRunningOperationOfTResult.cs

@@ -0,0 +1,13 @@
+namespace Umbraco.Cms.Core.Models;
+
+/// <summary>
+/// Represents a long-running operation.
+/// </summary>
+/// <typeparam name="TResult">The type of the result of the long-running operation.</typeparam>
+public class LongRunningOperation<TResult> : LongRunningOperation
+{
+    /// <summary>
+    /// Gets or sets the result of the long-running operation.
+    /// </summary>
+    public TResult? Result { get; set; }
+}

src/Umbraco.Core/Models/LongRunningOperationStatus.cs

@@ -0,0 +1,32 @@
+namespace Umbraco.Cms.Core.Models;
+
+/// <summary>
+/// Represents the status of a long-running operation.
+/// </summary>
+public enum LongRunningOperationStatus
+{
+    /// <summary>
+    /// The operation has finished successfully.
+    /// </summary>
+    Success,
+
+    /// <summary>
+    /// The operation has failed.
+    /// </summary>
+    Failed,
+
+    /// <summary>
+    /// The operation has been queued.
+    /// </summary>
+    Enqueued,
+
+    /// <summary>
+    /// The operation is currently running.
+    /// </summary>
+    Running,
+
+    /// <summary>
+    /// The operation wasn't updated within the expected time frame and is considered stale.
+    /// </summary>
+    Stale,
+}

src/Umbraco.Core/Persistence/Constants-DatabaseSchema.cs

@@ -98,6 +98,8 @@ public static class Tables
             public const string Webhook2Headers = Webhook + "2Headers";
             public const string WebhookLog = Webhook + "Log";
             public const string WebhookRequest = Webhook + "Request";
+
+            public const string LongRunningOperation = TableNamePrefix + "LongRunningOperation";
         }
     }
 }

src/Umbraco.Core/Persistence/Constants-Locks.cs

@@ -80,5 +80,10 @@ public static class Locks
         ///     All webhook logs.
         /// </summary>
         public const int WebhookLogs = -343;
+
+        /// <summary>
+        ///     Long-running operations.
+        /// </summary>
+        public const int LongRunningOperations = -344;
     }
 }