Merge pull request #10880 from umbraco/v9/bugfix/suppress-notifications-migrations

Suppress scope notifications during migrations

Author: Paul Johnson

src/Umbraco.Core/Notifications/RuntimeUnattendedUpgradeNotification.cs

@@ -1,5 +1,6 @@
 namespace Umbraco.Cms.Core.Notifications
 {
+
     /// <summary>
     /// Used to notify when the core runtime can do an unattended upgrade.
     /// </summary>

src/Umbraco.Core/Umbraco.Core.csproj

@@ -61,6 +61,5 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="ContentEditing" />
     </ItemGroup>
 </Project>

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

@@ -29,6 +29,8 @@ internal static IUmbracoBuilder AddInstaller(this IUmbracoBuilder builder)
             builder.Services.AddTransient<InstallStepCollection>();
             builder.Services.AddUnique<InstallHelper>();
 
+            builder.Services.AddTransient<PackageMigrationRunner>();
+
             return builder;
         }
     }

src/Umbraco.Infrastructure/Install/InstallSteps/DatabaseUpgradeStep.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -61,7 +61,7 @@ public override Task<InstallSetupResult> ExecuteAsync(object model)
                 }
             }
 
-            return Task.FromResult<InstallSetupResult>(null);
+            return Task.FromResult((InstallSetupResult)null);
         }
 
         public override bool RequiresExecution(object model)

src/Umbraco.Infrastructure/Install/InstallSteps/NewInstallStep.cs

@@ -137,6 +137,9 @@ private InstallState GetInstallState()
         {
             var installState = InstallState.Unknown;
 
+            // TODO: we need to do a null check here since this could be entirely missing and we end up with a null ref
+            // exception in the installer.
+
             var databaseSettings = _connectionStrings.UmbracoConnectionString;
 
             var hasConnString = databaseSettings != null && _databaseBuilder.IsDatabaseConfigured;

src/Umbraco.Infrastructure/Install/PackageMigrationRunner.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Logging;
+using Umbraco.Cms.Core.Packaging;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Infrastructure.Migrations.Upgrade;
+using Umbraco.Extensions;
+using Umbraco.Cms.Core.Migrations;
+using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Infrastructure.Migrations;
+using Umbraco.Cms.Infrastructure.Migrations.Notifications;
+using Umbraco.Cms.Core;
+
+namespace Umbraco.Cms.Infrastructure.Install
+{
+    /// <summary>
+    /// Runs the package migration plans
+    /// </summary>
+    public class PackageMigrationRunner
+    {
+        private readonly IProfilingLogger _profilingLogger;
+        private readonly IScopeProvider _scopeProvider;
+        private readonly PendingPackageMigrations _pendingPackageMigrations;
+        private readonly IMigrationPlanExecutor _migrationPlanExecutor;
+        private readonly IKeyValueService _keyValueService;
+        private readonly IEventAggregator _eventAggregator;
+        private readonly Dictionary<string, PackageMigrationPlan> _packageMigrationPlans;
+
+        public PackageMigrationRunner(
+            IProfilingLogger profilingLogger,
+            IScopeProvider scopeProvider,
+            PendingPackageMigrations pendingPackageMigrations,
+            PackageMigrationPlanCollection packageMigrationPlans,
+            IMigrationPlanExecutor migrationPlanExecutor,
+            IKeyValueService keyValueService,
+            IEventAggregator eventAggregator)
+        {
+            _profilingLogger = profilingLogger;
+            _scopeProvider = scopeProvider;
+            _pendingPackageMigrations = pendingPackageMigrations;
+            _migrationPlanExecutor = migrationPlanExecutor;
+            _keyValueService = keyValueService;
+            _eventAggregator = eventAggregator;
+            _packageMigrationPlans = packageMigrationPlans.ToDictionary(x => x.Name);            
+        }
+
+        /// <summary>
+        /// Runs all migration plans for a package name if any are pending.
+        /// </summary>
+        /// <param name="packageName"></param>
+        /// <returns></returns>
+        public IEnumerable<ExecutedMigrationPlan> RunPackageMigrationsIfPending(string packageName)
+        {
+            IReadOnlyDictionary<string, string> keyValues = _keyValueService.FindByKeyPrefix(Constants.Conventions.Migrations.KeyValuePrefix);
+            IReadOnlyList<string> pendingMigrations = _pendingPackageMigrations.GetPendingPackageMigrations(keyValues);
+
+            IEnumerable<string> packagePlans = _packageMigrationPlans.Values
+                .Where(x => x.PackageName.InvariantEquals(packageName))
+                .Where(x => pendingMigrations.Contains(x.Name))
+                .Select(x => x.Name);
+
+            return RunPackagePlans(packagePlans);
+        }
+
+        /// <summary>
+        /// Runs the all specified package migration plans and publishes a <see cref="MigrationPlansExecutedNotification"/>
+        /// if all are successful.
+        /// </summary>
+        /// <param name="plansToRun"></param>
+        /// <returns></returns>
+        /// <exception cref="Exception">If any plan fails it will throw an exception.</exception>
+        public IEnumerable<ExecutedMigrationPlan> RunPackagePlans(IEnumerable<string> plansToRun)
+        {
+            var results = new List<ExecutedMigrationPlan>();
+
+            // Create an explicit scope around all package migrations so they are
+            // all executed in a single transaction. If one package migration fails,
+            // none of them will be committed. This is intended behavior so we can
+            // ensure when we publish the success notification that is is done when they all succeed.
+            using (IScope scope = _scopeProvider.CreateScope(autoComplete: true))
+            {
+                foreach (var migrationName in plansToRun)
+                {
+                    if (!_packageMigrationPlans.TryGetValue(migrationName, out PackageMigrationPlan plan))
+                    {
+                        throw new InvalidOperationException("Cannot find package migration plan " + migrationName);
+                    }
+
+                    using (_profilingLogger.TraceDuration<PackageMigrationRunner>(
+                        "Starting unattended package migration for " + migrationName,
+                        "Unattended upgrade completed for " + migrationName))
+                    {
+                        var upgrader = new Upgrader(plan);
+                        // This may throw, if so the transaction will be rolled back
+                        results.Add(upgrader.Execute(_migrationPlanExecutor, _scopeProvider, _keyValueService));
+                    }
+                }
+            }
+
+            var executedPlansNotification = new MigrationPlansExecutedNotification(results);
+            _eventAggregator.Publish(executedPlansNotification);
+
+            return results;
+        }
+    }
+}

src/Umbraco.Infrastructure/Install/UnattendedUpgrader.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -8,47 +7,40 @@
 using Umbraco.Cms.Core.Exceptions;
 using Umbraco.Cms.Core.Logging;
 using Umbraco.Cms.Core.Notifications;
-using Umbraco.Cms.Core.Packaging;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Infrastructure.Migrations.Install;
 using Umbraco.Cms.Infrastructure.Migrations.Upgrade;
 using Umbraco.Cms.Infrastructure.Runtime;
 using Umbraco.Extensions;
-using Umbraco.Cms.Core.Migrations;
-using Umbraco.Cms.Core.Scoping;
 using Umbraco.Cms.Core;
+using Umbraco.Cms.Infrastructure.Migrations;
 
 namespace Umbraco.Cms.Infrastructure.Install
 {
+    /// <summary>
+    /// Handles <see cref="RuntimeUnattendedUpgradeNotification"/> to execute the unattended Umbraco upgrader
+    /// or the unattended Package migrations runner.
+    /// </summary>
     public class UnattendedUpgrader : INotificationAsyncHandler<RuntimeUnattendedUpgradeNotification>
     {
         private readonly IProfilingLogger _profilingLogger;
         private readonly IUmbracoVersion _umbracoVersion;
         private readonly DatabaseBuilder _databaseBuilder;
         private readonly IRuntimeState _runtimeState;
-        private readonly PackageMigrationPlanCollection _packageMigrationPlans;
-        private readonly IMigrationPlanExecutor _migrationPlanExecutor;
-        private readonly IScopeProvider _scopeProvider;
-        private readonly IKeyValueService _keyValueService;
+        private readonly PackageMigrationRunner _packageMigrationRunner;
 
         public UnattendedUpgrader(
             IProfilingLogger profilingLogger,
             IUmbracoVersion umbracoVersion,
             DatabaseBuilder databaseBuilder,
             IRuntimeState runtimeState,
-            PackageMigrationPlanCollection packageMigrationPlans,
-            IMigrationPlanExecutor migrationPlanExecutor,
-            IScopeProvider scopeProvider,
-            IKeyValueService keyValueService)
+            PackageMigrationRunner packageMigrationRunner)
         {
             _profilingLogger = profilingLogger ?? throw new ArgumentNullException(nameof(profilingLogger));
             _umbracoVersion = umbracoVersion ?? throw new ArgumentNullException(nameof(umbracoVersion));
             _databaseBuilder = databaseBuilder ?? throw new ArgumentNullException(nameof(databaseBuilder));
             _runtimeState = runtimeState ?? throw new ArgumentNullException(nameof(runtimeState));
-            _packageMigrationPlans = packageMigrationPlans;
-            _migrationPlanExecutor = migrationPlanExecutor;
-            _scopeProvider = scopeProvider;
-            _keyValueService = keyValueService;
+            _packageMigrationRunner = packageMigrationRunner;
         }
 
         public Task HandleAsync(RuntimeUnattendedUpgradeNotification notification, CancellationToken cancellationToken)
@@ -69,7 +61,6 @@ public Task HandleAsync(RuntimeUnattendedUpgradeNotification notification, Cance
                             {
                                 var innerException = new UnattendedInstallException("An error occurred while running the unattended upgrade.\n" + result.Message);
                                 _runtimeState.Configure(Core.RuntimeLevel.BootFailed, Core.RuntimeLevelReason.BootFailedOnException, innerException);
-                                return Task.CompletedTask;
                             }
 
                             notification.UnattendedUpgradeResult = RuntimeUnattendedUpgradeNotification.UpgradeResult.CoreUpgradeComplete;
@@ -83,73 +74,36 @@ public Task HandleAsync(RuntimeUnattendedUpgradeNotification notification, Cance
                         {
                             throw new InvalidOperationException($"The required key {RuntimeState.PendingPacakgeMigrationsStateKey} does not exist in startup state");
                         }
-                        
+
                         if (pendingMigrations.Count == 0)
                         {
                             throw new InvalidOperationException("No pending migrations found but the runtime level reason is " + Core.RuntimeLevelReason.UpgradePackageMigrations);
                         }
 
-                        var exceptions = new List<Exception>();
-                        var packageMigrationsPlans = _packageMigrationPlans.ToDictionary(x => x.Name);
-
-                        foreach (var migrationName in pendingMigrations)
+                        try
                         {
-                            if (!packageMigrationsPlans.TryGetValue(migrationName, out PackageMigrationPlan plan))
-                            {
-                                throw new InvalidOperationException("Cannot find package migration plan " + migrationName);
-                            }
-
-                            using (_profilingLogger.TraceDuration<UnattendedUpgrader>(
-                                "Starting unattended package migration for " + migrationName,
-                                "Unattended upgrade completed for " + migrationName))
-                            {
-                                var upgrader = new Upgrader(plan);
-
-                                try
-                                {
-                                    upgrader.Execute(_migrationPlanExecutor, _scopeProvider, _keyValueService);
-                                }
-                                catch (Exception ex)
-                                {
-                                    exceptions.Add(new UnattendedInstallException("Unattended package migration failed for " + migrationName, ex));                                    
-                                }
-                            }
+                            IEnumerable<ExecutedMigrationPlan> result = _packageMigrationRunner.RunPackagePlans(pendingMigrations);
+                            notification.UnattendedUpgradeResult = RuntimeUnattendedUpgradeNotification.UpgradeResult.PackageMigrationComplete;
                         }
-
-                        if (exceptions.Count > 0)
+                        catch (Exception ex )
                         {
+                            SetRuntimeError(ex);
                             notification.UnattendedUpgradeResult = RuntimeUnattendedUpgradeNotification.UpgradeResult.HasErrors;
-                            SetRuntimeErrors(exceptions);
-                        }
-                        else
-                        {
-                            notification.UnattendedUpgradeResult = RuntimeUnattendedUpgradeNotification.UpgradeResult.PackageMigrationComplete;
                         }
                     }
                     break;
                     default:
                         throw new InvalidOperationException("Invalid reason " + _runtimeState.Reason);
                 }
             }
+
             return Task.CompletedTask;
         }
 
-        private void SetRuntimeErrors(List<Exception> exception)
-        {            
-            Exception innerException;
-            if (exception.Count == 1)
-            {
-                innerException = exception[0];
-            }
-            else
-            {
-                innerException = new AggregateException(exception);
-            }
-
-            _runtimeState.Configure(
+        private void SetRuntimeError(Exception exception)
+            => _runtimeState.Configure(
                 RuntimeLevel.BootFailed,
                 RuntimeLevelReason.BootFailedOnException,
-                innerException);
-        }
+                exception);
     }
 }

src/Umbraco.Infrastructure/Migrations/ExecutedMigrationPlan.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace Umbraco.Cms.Infrastructure.Migrations
+{
+    public class ExecutedMigrationPlan
+    {
+        public ExecutedMigrationPlan(MigrationPlan plan, string initialState, string finalState)
+        {
+            Plan = plan;
+            InitialState = initialState ?? throw new ArgumentNullException(nameof(initialState));
+            FinalState = finalState ?? throw new ArgumentNullException(nameof(finalState));
+        }
+
+        public MigrationPlan Plan { get; }
+        public string InitialState { get; }
+        public string FinalState { get; }
+    }
+}

src/Umbraco.Infrastructure/Migrations/IMigrationExpression.cs

@@ -1,4 +1,4 @@
-namespace Umbraco.Cms.Infrastructure.Migrations
+namespace Umbraco.Cms.Infrastructure.Migrations
 {
     /// <summary>
     /// Marker interface for migration expressions

src/Umbraco.Infrastructure/Migrations/IMigrationPlanExecutor.cs

@@ -1,3 +1,4 @@
+using System.Threading.Tasks;
 using Umbraco.Cms.Infrastructure.Migrations;
 
 namespace Umbraco.Cms.Core.Migrations