Abstract away the Examine commit monitoring

src/Umbraco.Cms.Search.Provider.Examine/DependencyInjection/UmbracoBuilderExtensions.cs

@@ -47,7 +47,7 @@ public static IUmbracoBuilder AddExamineSearchProvider(this IUmbracoBuilder buil
 
             // NOTE: this notification handler should ONLY be active when zero downtime reindexing is in effect
             builder.AddNotificationHandler<IndexRebuildStartingNotification, ZeroDowntimeRebuildNotificationHandler>();
-            builder.AddNotificationHandler<IndexRebuildCompletedNotification, ZeroDowntimeRebuildNotificationHandler>();
+            builder.AddNotificationAsyncHandler<IndexRebuildCompletedNotification, ZeroDowntimeRebuildNotificationHandler>();
         }
         else
         {
@@ -59,6 +59,8 @@ public static IUmbracoBuilder AddExamineSearchProvider(this IUmbracoBuilder buil
             builder.Services.AddSingleton<IActiveIndexManager, NoopActiveIndexManager>();
         }
 
+        builder.Services.AddSingleton<IIndexCommitMonitor, IndexCommitMonitor>();
+
         // This is needed, due to locking of indexes on Azure, to read more on this issue go here: https://github.com/umbraco/Umbraco-CMS/pull/15571
         builder.Services.AddSingleton<UmbracoTempEnvFileSystemDirectoryFactory>();
         builder.Services.RemoveAll<SyncedFileSystemDirectoryFactory>();

src/Umbraco.Cms.Search.Provider.Examine/NotificationHandlers/ZeroDowntimeRebuildNotificationHandler.cs

@@ -1,5 +1,4 @@
 using Examine;
-using Examine.Lucene.Providers;
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Search.Core.Notifications;
@@ -10,35 +9,48 @@ namespace Umbraco.Cms.Search.Provider.Examine.NotificationHandlers;
 // NOTE: This notification handler is only active when zero downtime reindexing is in effect
 internal sealed class ZeroDowntimeRebuildNotificationHandler :
     INotificationHandler<IndexRebuildStartingNotification>,
-    INotificationHandler<IndexRebuildCompletedNotification>
+    INotificationAsyncHandler<IndexRebuildCompletedNotification>
 {
     private static readonly TimeSpan CommitTimeout = TimeSpan.FromSeconds(30);
 
     private readonly IActiveIndexManager _activeIndexManager;
     private readonly IExamineManager _examineManager;
+    private readonly IIndexCommitMonitor _indexCommitMonitor;
     private readonly ILogger<ZeroDowntimeRebuildNotificationHandler> _logger;
 
     public ZeroDowntimeRebuildNotificationHandler(
         IActiveIndexManager activeIndexManager,
         IExamineManager examineManager,
+        IIndexCommitMonitor indexCommitMonitor,
         ILogger<ZeroDowntimeRebuildNotificationHandler> logger)
     {
         _activeIndexManager = activeIndexManager;
         _examineManager = examineManager;
+        _indexCommitMonitor = indexCommitMonitor;
         _logger = logger;
     }
 
     public void Handle(IndexRebuildStartingNotification notification)
         => _activeIndexManager.StartRebuilding(notification.IndexAlias);
 
-    public void Handle(IndexRebuildCompletedNotification notification)
+    public async Task HandleAsync(IndexRebuildCompletedNotification notification, CancellationToken cancellationToken)
     {
         var shadowIndexName = _activeIndexManager.ResolveShadowIndexName(notification.IndexAlias);
 
         // Examine's LuceneIndex.IndexItems() commits asynchronously. We must wait for the
         // commit to complete before checking document count, otherwise we'll see 0 documents
         // and incorrectly cancel the swap.
-        WaitForShadowCommit(shadowIndexName);
+        var committed = await _indexCommitMonitor.WaitForCommitAsync(shadowIndexName, cancellationToken);
+        if (cancellationToken.IsCancellationRequested)
+        {
+            _logger.LogInformation("Cancellation requested before completion of shadow index swap for {ShadowIndex}.", shadowIndexName);
+            return;
+        }
+
+        if (committed is false)
+        {
+            _logger.LogWarning("Timed out waiting for shadow index {ShadowIndex} to commit after rebuild", shadowIndexName);
+        }
 
         if (IsShadowIndexHealthy(shadowIndexName))
         {
@@ -55,48 +67,6 @@ public void Handle(IndexRebuildCompletedNotification notification)
         }
     }
 
-    private void WaitForShadowCommit(string physicalIndexName)
-    {
-        if (_examineManager.TryGetIndex(physicalIndexName, out IIndex? index) is false || index is not LuceneIndex luceneIndex)
-        {
-            return;
-        }
-
-        if (index is IIndexStats stats && stats.GetDocumentCount() > 0)
-        {
-            return;
-        }
-
-        var committed = false;
-        void OnCommitted(object? sender, EventArgs e) => committed = true;
-        luceneIndex.IndexCommitted += OnCommitted;
-
-        try
-        {
-            // Re-check after subscribing to avoid a race where the commit happened
-            // between the initial check and subscribing to the event.
-            if (index is IIndexStats statsAfterSubscribe && statsAfterSubscribe.GetDocumentCount() > 0)
-            {
-                return;
-            }
-
-            var stopwatch = System.Diagnostics.Stopwatch.StartNew();
-            while (!committed && stopwatch.Elapsed < CommitTimeout)
-            {
-                Thread.Sleep(100);
-            }
-
-            if (!committed)
-            {
-                _logger.LogWarning("Timed out waiting for shadow index {ShadowIndex} to commit after rebuild", physicalIndexName);
-            }
-        }
-        finally
-        {
-            luceneIndex.IndexCommitted -= OnCommitted;
-        }
-    }
-
     private void ClearShadowIndex(string indexAlias)
     {
         var shadowIndexName = _activeIndexManager.ResolveShadowIndexName(indexAlias);

src/Umbraco.Cms.Search.Provider.Examine/Services/IIndexCommitMonitor.cs

@@ -0,0 +1,6 @@
+namespace Umbraco.Cms.Search.Provider.Examine.Services;
+
+public interface IIndexCommitMonitor
+{
+    Task<bool> WaitForCommitAsync(string indexAlias, CancellationToken cancellationToken);
+}

src/Umbraco.Cms.Search.Provider.Examine/Services/IndexCommitMonitor.cs

@@ -0,0 +1,54 @@
+using Examine;
+using Examine.Lucene.Providers;
+
+namespace Umbraco.Cms.Search.Provider.Examine.Services;
+
+internal sealed class IndexCommitMonitor : IIndexCommitMonitor
+{
+    private static readonly TimeSpan CommitTimeout = TimeSpan.FromSeconds(30);
+
+    private readonly IExamineManager _examineManager;
+
+    public IndexCommitMonitor(IExamineManager examineManager)
+        => _examineManager = examineManager;
+
+    public async Task<bool> WaitForCommitAsync(string indexAlias, CancellationToken cancellationToken)
+    {
+        if (_examineManager.TryGetIndex(indexAlias, out IIndex? index) is false || index is not LuceneIndex luceneIndex)
+        {
+            return false;
+        }
+
+        if (index is IIndexStats stats && stats.GetDocumentCount() > 0)
+        {
+            return false;
+        }
+
+        var committed = false;
+        EventHandler onCommitted = (_, _) => committed = true;
+
+        try
+        {
+            luceneIndex.IndexCommitted += onCommitted;
+
+            // Re-check after subscribing to avoid a race where the commit happened
+            // between the initial check and subscribing to the event.
+            if (index is IIndexStats statsAfterSubscribe && statsAfterSubscribe.GetDocumentCount() > 0)
+            {
+                return true;
+            }
+
+            var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+            while (!committed && stopwatch.Elapsed < CommitTimeout)
+            {
+                await Task.Delay(CommitTimeout);
+            }
+
+            return committed;
+        }
+        finally
+        {
+            luceneIndex.IndexCommitted -= onCommitted;
+        }
+    }
+}

src/Umbraco.Test.Search.Examine.Integration/Extensions/ServiceCollectionExtensions.cs

@@ -38,6 +38,8 @@ public static IServiceCollection AddExamineSearchProviderServicesForTest<TIndex,
         // Override to use ActiveIndexManager for zero-downtime reindexing in integration tests
         services.AddSingleton<IActiveIndexManager, ActiveIndexManager>();
 
+        services.AddSingleton<IIndexCommitMonitor, IndexCommitMonitor>();
+
         return services;
     }
 

src/Umbraco.Test.Search.Examine.Integration/Extensions/UmbracoBuilderExtensions.cs

@@ -20,7 +20,7 @@ public static IUmbracoBuilder AddExamineSearchProviderForTest<TIndex, TDirectory
         builder.AddNotificationHandler<MemberSavedNotification, MemberSavedDistributedCacheNotificationHandler>();
         builder.AddNotificationHandler<MemberDeletedNotification, MemberDeletedDistributedCacheNotificationHandler>();
         builder.AddNotificationHandler<IndexRebuildStartingNotification, ZeroDowntimeRebuildNotificationHandler>();
-        builder.AddNotificationHandler<IndexRebuildCompletedNotification, ZeroDowntimeRebuildNotificationHandler>();
+        builder.AddNotificationAsyncHandler<IndexRebuildCompletedNotification, ZeroDowntimeRebuildNotificationHandler>();
 
         return builder;
     }