Added Cache Instructions lock, to avoid deadlocks

Author: bergmania

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

@@ -70,5 +70,10 @@ public static class Locks
         ///     ScheduledPublishing job.
         /// </summary>
         public const int ScheduledPublishing = -341;
+
+        /// <summary>
+        ///     CacheInstructions service.
+        /// </summary>
+        public const int CacheInstructions = -342;
     }
 }

src/Umbraco.Core/Services/ContentTypeService.cs

@@ -29,7 +29,7 @@ public ContentTypeService(
     // beware! order is important to avoid deadlocks
     protected override int[] ReadLockIds { get; } = { Constants.Locks.ContentTypes };
 
-    protected override int[] WriteLockIds { get; } = { Constants.Locks.ContentTree, Constants.Locks.ContentTypes };
+    protected override int[] WriteLockIds { get; } = { Constants.Locks.ContentTree, Constants.Locks.ContentTypes, Constants.Locks.CacheInstructions};
 
     protected override Guid ContainedObjectType => Constants.ObjectTypes.DocumentType;
 

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

@@ -1015,6 +1015,8 @@ private void CreateLockData()
             new LockDto { Id = Constants.Locks.Languages, Name = "Languages" });
         _database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false,
             new LockDto { Id = Constants.Locks.ScheduledPublishing, Name = "ScheduledPublishing" });
+        _database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false,
+            new LockDto { Id = Constants.Locks.CacheInstructions, Name = "CacheInstructions" });
 
         _database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false,
             new LockDto { Id = Constants.Locks.MainDom, Name = "MainDom" });

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

@@ -7,6 +7,7 @@
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_10_2_0;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_10_5_0;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_10_7_0;
+using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_10_9_0;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_8_0_0;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_8_0_1;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_8_1_0;
@@ -307,5 +308,8 @@ protected void DefinePlan()
 
         // to 10.7.0
         To<MigrateTagsFromNVarcharToNText>("{EF93F398-1385-4F07-808A-D3C518984442}");
+
+        // to 10.9.0
+        To<AddCacheInstructionLock>("{75AB5D21-4464-40F5-A9D1-3E8CE0D89E38}");
     }
 }

src/Umbraco.Infrastructure/Migrations/Upgrade/V_10_9_0/AddCacheInstructionLock.cs

@@ -0,0 +1,30 @@
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_10_9_0;
+
+internal class AddCacheInstructionLock : MigrationBase
+{
+    public AddCacheInstructionLock(IMigrationContext context)
+        : base(context)
+    {
+    }
+
+    protected override void Migrate()
+    {
+        var currentCount = Database
+            .Fetch<int>(
+                Sql()
+                    .SelectCount()
+                    .From<LockDto>()
+                    .Where<LockDto>(x => x.Id == Constants.Locks.CacheInstructions))
+            .FirstOrDefault();
+        if (currentCount == 0)
+        {
+            Database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false,
+                new LockDto { Id = Constants.Locks.CacheInstructions, Name = "CacheInstructions" });
+        }
+
+    }
+}

src/Umbraco.Infrastructure/Services/CacheInstructionService.cs

@@ -2,6 +2,7 @@
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Events;
@@ -77,6 +78,7 @@ public CacheInstructionService(
             public bool IsColdBootRequired(int lastId)
             {
                 using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
+                scope.ReadLock(Constants.Locks.CacheInstructions);
                 if (lastId <= 0)
                 {
                     var count = _cacheInstructionRepository.CountAll();
@@ -103,6 +105,7 @@ public bool IsColdBootRequired(int lastId)
             public bool IsInstructionCountOverLimit(int lastId, int limit, out int count)
             {
                 using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
+                scope.ReadLock(Constants.Locks.CacheInstructions);
                 // Check for how many instructions there are to process, each row contains a count of the number of instructions contained in each
                 // row so we will sum these numbers to get the actual count.
                 count = _cacheInstructionRepository.CountPendingInstructions(lastId);
@@ -113,6 +116,7 @@ public bool IsInstructionCountOverLimit(int lastId, int limit, out int count)
             public int GetMaxInstructionId()
             {
                 using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
+                scope.ReadLock(Constants.Locks.CacheInstructions);
                 return _cacheInstructionRepository.GetMaxId();
             }
 
@@ -123,6 +127,7 @@ public void DeliverInstructions(IEnumerable<RefreshInstruction> instructions, st
 
                 using (ICoreScope scope = ScopeProvider.CreateCoreScope())
                 {
+                    scope.WriteLock(Constants.Locks.CacheInstructions);
                     _cacheInstructionRepository.Add(entity);
                     scope.Complete();
                 }
@@ -134,6 +139,7 @@ public void DeliverInstructionsInBatches(IEnumerable<RefreshInstruction> instruc
                 // Write the instructions but only create JSON blobs with a max instruction count equal to MaxProcessingInstructionCount.
                 using (ICoreScope scope = ScopeProvider.CreateCoreScope())
                 {
+                    scope.WriteLock(Constants.Locks.CacheInstructions);
                     foreach (IEnumerable<RefreshInstruction> instructionsBatch in instructions.InGroupsOf(
                                  _globalSettings.DatabaseServerMessenger.MaxProcessingInstructionCount))
                     {
@@ -157,6 +163,7 @@ public ProcessInstructionsResult ProcessInstructions(
                 using (_profilingLogger.DebugDuration<CacheInstructionService>("Syncing from database..."))
                 using (ICoreScope scope = ScopeProvider.CreateCoreScope())
                 {
+                    scope.ReadLock(Constants.Locks.CacheInstructions);
                     var numberOfInstructionsProcessed = ProcessDatabaseInstructions(cacheRefreshers, cancellationToken, localIdentity, ref lastId);
 
                     // Check for pruning throttling.
@@ -251,6 +258,7 @@ private int ProcessDatabaseInstructions(CacheRefresherCollection cacheRefreshers
                     List<RefreshInstruction> instructionBatch = GetAllInstructions(jsonInstructions);
 
                     // Process as per-normal.
+
                     var success = ProcessDatabaseInstructions(cacheRefreshers, instructionBatch, instruction, processed, cancellationToken, ref lastId);
 
                     // If they couldn't be all processed (i.e. we're shutting down) then exit.