Filesystem based MainDomLock & extract interface for MainDomKey generation (#12037)

* Extract MainDomKey generation to its own class to ease customization.

Also add discriminator config value to GlobalSettings for advanced users.
Prevents a mandatory custom implementation, should be good enough for
the vast majority of use cases.

* Prevent duplicate runs of ScheduledPublishing during slot swap.

* Add filesystem based MainDomLock

Author: Paul Johnson

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

@@ -137,6 +137,14 @@ public class GlobalSettings
         /// </summary>
         public string MainDomLock { get; set; } = string.Empty;
 
+        /// <summary>
+        /// Gets or sets a value to discriminate MainDom boundaries.
+        /// <para>
+        /// Generally the default should suffice but useful for advanced scenarios e.g. azure deployment slot based zero downtime deployments.
+        /// </para>
+        /// </summary>
+        public string MainDomKeyDiscriminator { get; set; } = string.Empty;
+
         /// <summary>
         /// Gets or sets the telemetry ID.
         /// </summary>

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

@@ -65,6 +65,11 @@ public static class Locks
             /// All languages.
             /// </summary>
             public const int Languages = -340;
+
+            /// <summary>
+            /// ScheduledPublishing job.
+            /// </summary>
+            public const int ScheduledPublishing = -341;
         }
     }
 }

src/Umbraco.Core/Runtime/IMainDomKeyGenerator.cs

@@ -0,0 +1,13 @@
+namespace Umbraco.Cms.Core.Runtime
+{
+    /// <summary>
+    /// Defines a class which can generate a distinct key for a MainDom boundary.
+    /// </summary>
+    public interface IMainDomKeyGenerator
+    {
+        /// <summary>
+        /// Returns a key that signifies a MainDom boundary.
+        /// </summary>
+        string GenerateKey();
+    }
+}

src/Umbraco.Core/Runtime/MainDom.cs

@@ -87,7 +87,7 @@ public bool Register(Action install = null, Action release = null, int weight =
 
                 if (_isMainDom.HasValue == false)
                 {
-                    throw new InvalidOperationException("Register called when MainDom has not been acquired");
+                    throw new InvalidOperationException("Register called before IsMainDom has been established");
                 }
                 else if (_isMainDom == false)
                 {
@@ -225,7 +225,7 @@ public bool IsMainDom
             {
                 if (!_isMainDom.HasValue)
                 {
-                    throw new InvalidOperationException("MainDom has not been acquired yet");
+                    throw new InvalidOperationException("IsMainDom has not been established yet");
                 }
                 return _isMainDom.Value;
             }

src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs

@@ -218,6 +218,7 @@ private static IUmbracoBuilder AddLogging(this IUmbracoBuilder builder)
 
         private static IUmbracoBuilder AddMainDom(this IUmbracoBuilder builder)
         {
+            builder.Services.AddSingleton<IMainDomKeyGenerator, DefaultMainDomKeyGenerator>();
             builder.Services.AddSingleton<IMainDomLock>(factory =>
             {
                 var globalSettings = factory.GetRequiredService<IOptions<GlobalSettings>>();
@@ -229,15 +230,20 @@ private static IUmbracoBuilder AddMainDom(this IUmbracoBuilder builder)
                 var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
                 var loggerFactory = factory.GetRequiredService<ILoggerFactory>();
                 var npocoMappers = factory.GetRequiredService<NPocoMapperCollection>();
+                var mainDomKeyGenerator = factory.GetRequiredService<IMainDomKeyGenerator>();
+
+                if (globalSettings.Value.MainDomLock == "FileSystemMainDomLock")
+                {
+                    return new FileSystemMainDomLock(loggerFactory.CreateLogger<FileSystemMainDomLock>(), mainDomKeyGenerator, hostingEnvironment);
+                }
 
                 return globalSettings.Value.MainDomLock.Equals("SqlMainDomLock") || isWindows == false
                     ? (IMainDomLock)new SqlMainDomLock(
-                            loggerFactory.CreateLogger<SqlMainDomLock>(),
                             loggerFactory,
                             globalSettings,
                             connectionStrings,
                             dbCreator,
-                            hostingEnvironment,
+                            mainDomKeyGenerator,
                             databaseSchemaCreatorFactory,
                             npocoMappers)
                     : new MainDomSemaphoreLock(loggerFactory.CreateLogger<MainDomSemaphoreLock>(), hostingEnvironment);

src/Umbraco.Infrastructure/HostedServices/ScheduledPublishing.cs

@@ -5,13 +5,15 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Runtime;
-using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Scoping;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Sync;
 using Umbraco.Cms.Core.Web;
+using Umbraco.Cms.Web.Common.DependencyInjection;
 
 namespace Umbraco.Cms.Infrastructure.HostedServices
 {
@@ -27,20 +29,16 @@ public class ScheduledPublishing : RecurringHostedServiceBase
         private readonly IMainDom _mainDom;
         private readonly IRuntimeState _runtimeState;
         private readonly IServerMessenger _serverMessenger;
+        private readonly IScopeProvider _scopeProvider;
         private readonly IServerRoleAccessor _serverRegistrar;
         private readonly IUmbracoContextFactory _umbracoContextFactory;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ScheduledPublishing"/> class.
         /// </summary>
-        /// <param name="runtimeState">Representation of the state of the Umbraco runtime.</param>
-        /// <param name="mainDom">Representation of the main application domain.</param>
-        /// <param name="serverRegistrar">Provider of server registrations to the distributed cache.</param>
-        /// <param name="contentService">Service for handling content operations.</param>
-        /// <param name="umbracoContextFactory">Service for creating and managing Umbraco context.</param>
-        /// <param name="logger">The typed logger.</param>
-        /// <param name="serverMessenger">Service broadcasting cache notifications to registered servers.</param>
-        /// <param name="backofficeSecurityFactory">Creates and manages <see cref="IBackOfficeSecurity"/> instances.</param>
+        // Note: Ignoring the two version notice rule as this class should probably be internal.
+        // We don't expect anyone downstream to be instantiating a HostedService
+        [Obsolete("This constructor will be removed in version 10, please use an alternative constructor.")]
         public ScheduledPublishing(
             IRuntimeState runtimeState,
             IMainDom mainDom,
@@ -49,6 +47,30 @@ public ScheduledPublishing(
             IUmbracoContextFactory umbracoContextFactory,
             ILogger<ScheduledPublishing> logger,
             IServerMessenger serverMessenger)
+            : this(
+                runtimeState,
+                mainDom,
+                serverRegistrar,
+                contentService,
+                umbracoContextFactory,
+                logger,
+                serverMessenger,
+                StaticServiceProvider.Instance.GetRequiredService<IScopeProvider>())
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ScheduledPublishing"/> class.
+        /// </summary>
+        public ScheduledPublishing(
+            IRuntimeState runtimeState,
+            IMainDom mainDom,
+            IServerRoleAccessor serverRegistrar,
+            IContentService contentService,
+            IUmbracoContextFactory umbracoContextFactory,
+            ILogger<ScheduledPublishing> logger,
+            IServerMessenger serverMessenger,
+            IScopeProvider scopeProvider)
             : base(TimeSpan.FromMinutes(1), DefaultDelay)
         {
             _runtimeState = runtimeState;
@@ -58,6 +80,7 @@ public ScheduledPublishing(
             _umbracoContextFactory = umbracoContextFactory;
             _logger = logger;
             _serverMessenger = serverMessenger;
+            _scopeProvider = scopeProvider;
         }
 
         public override Task PerformExecuteAsync(object state)
@@ -93,8 +116,6 @@ public override Task PerformExecuteAsync(object state)
 
             try
             {
-                // We don't need an explicit scope here because PerformScheduledPublish creates it's own scope
-                // so it's safe as it will create it's own ambient scope.
                 // Ensure we run with an UmbracoContext, because this will run in a background task,
                 // and developers may be using the UmbracoContext in the event handlers.
 
@@ -105,6 +126,14 @@ public override Task PerformExecuteAsync(object state)
                 // - and we should definitively *not* have to flush it here (should be auto)
 
                 using UmbracoContextReference contextReference = _umbracoContextFactory.EnsureUmbracoContext();
+                using IScope scope = _scopeProvider.CreateScope(autoComplete: true);
+
+                /* We used to assume that there will never be two instances running concurrently where (IsMainDom && ServerRole == SchedulingPublisher)
+                 * However this is possible during an azure deployment slot swap for the SchedulingPublisher instance when trying to achieve zero downtime deployments.
+                 * If we take a distributed write lock, we are certain that the multiple instances of the job will not run in parallel.
+                 * It's possible that during the swapping process we may run this job more frequently than intended but this is not of great concern and it's
+                 * only until the old SchedulingPublisher shuts down. */
+                scope.EagerWriteLock(Constants.Locks.ScheduledPublishing);
                 try
                 {
                     // Run

src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs

@@ -175,6 +175,7 @@ private void CreateLockData()
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Cms.Core.Constants.Locks.Domains, Name = "Domains" });
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Cms.Core.Constants.Locks.KeyValues, Name = "KeyValues" });
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Cms.Core.Constants.Locks.Languages, Name = "Languages" });
+            _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Cms.Core.Constants.Locks.ScheduledPublishing, Name = "ScheduledPublishing" });
 
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Cms.Core.Constants.Locks.MainDom, Name = "MainDom" });
         }

src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs

@@ -16,6 +16,7 @@
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_9_1_0;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_9_2_0;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_9_3_0;
+using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_9_4_0;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade
@@ -280,6 +281,8 @@ protected void DefinePlan()
             To<UpdateExternalLoginToUseKeyInsteadOfId>("{CA7A1D9D-C9D4-4914-BC0A-459E7B9C3C8C}");
             To<AddTwoFactorLoginTable>("{0828F206-DCF7-4F73-ABBB-6792275532EB}");
 
+            // TO 9.4.0
+            To<AddScheduledPublishingLock>("{DBBA1EA0-25A1-4863-90FB-5D306FB6F1E1}");
         }
     }
 }

src/Umbraco.Infrastructure/Migrations/Upgrade/V_9_4_0/AddScheduledPublishingLock.cs

@@ -0,0 +1,15 @@
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_9_4_0
+{
+    internal class AddScheduledPublishingLock : MigrationBase
+    {
+        public AddScheduledPublishingLock(IMigrationContext context)
+            : base(context)
+        {
+        }
+
+        protected override void Migrate() =>
+            Database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Cms.Core.Constants.Locks.ScheduledPublishing, Name = "ScheduledPublishing" });
+    }
+}

src/Umbraco.Infrastructure/Runtime/DefaultMainDomKeyGenerator.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Security.Cryptography;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Hosting;
+using Umbraco.Cms.Core.Runtime;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Infrastructure.Runtime
+{
+
+    internal class DefaultMainDomKeyGenerator : IMainDomKeyGenerator
+    {
+        private readonly IHostingEnvironment _hostingEnvironment;
+        private readonly IOptionsMonitor<GlobalSettings> _globalSettings;
+
+        public DefaultMainDomKeyGenerator(IHostingEnvironment hostingEnvironment, IOptionsMonitor<GlobalSettings> globalSettings)
+        {
+            _hostingEnvironment = hostingEnvironment;
+            _globalSettings = globalSettings;
+        }
+
+        public string GenerateKey()
+        {
+            var machineName = Environment.MachineName;
+            var mainDomId = MainDom.GetMainDomId(_hostingEnvironment);
+            var discriminator = _globalSettings.CurrentValue.MainDomKeyDiscriminator;
+
+            var rawKey = $"{machineName}{mainDomId}{discriminator}";
+
+            return rawKey.GenerateHash<SHA1>();
+        }
+    }
+}