Remove CoreInitialComponent

src/Umbraco.Infrastructure/Runtime/CoreInitialComposer.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Examine;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -38,6 +38,7 @@ using Umbraco.Core.Templates;
 using Umbraco.Examine;
 using Umbraco.Infrastructure.Examine;
 using Umbraco.Infrastructure.Media;
+using Umbraco.Infrastructure.Runtime;
 using Umbraco.Web;
 using Umbraco.Web.Actions;
 using Umbraco.Web.Cache;
@@ -66,11 +67,12 @@ namespace Umbraco.Core.Runtime
 {
     // core's initial composer composes before all core composers
     [ComposeBefore(typeof(ICoreComposer))]
-    public class CoreInitialComposer : ComponentComposer<CoreInitialComponent>
+    public class CoreInitialComposer : IComposer
     {
-        public override void Compose(IUmbracoBuilder builder)
+        /// <inheritdoc/>
+        public void Compose(IUmbracoBuilder builder)
         {
-            base.Compose(builder);
+            builder.AddNotificationHandler<UmbracoApplicationStarting, EssentialDirectoryCreator>();
 
             // composers
             builder

src/Umbraco.Infrastructure/Runtime/CoreRuntime.cs

@@ -1,7 +1,10 @@
-using System;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Umbraco.Core;
 using Umbraco.Core.Composing;
+using Umbraco.Core.Events;
 using Umbraco.Core.Hosting;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
@@ -10,71 +13,102 @@ namespace Umbraco.Infrastructure.Runtime
 {
     public class CoreRuntime : IRuntime
     {
-        public IRuntimeState State { get; }
-
         private readonly ILogger<CoreRuntime> _logger;
+        private readonly ILoggerFactory _loggerFactory;
         private readonly ComponentCollection _components;
         private readonly IApplicationShutdownRegistry _applicationShutdownRegistry;
         private readonly IProfilingLogger _profilingLogger;
         private readonly IMainDom _mainDom;
         private readonly IUmbracoDatabaseFactory _databaseFactory;
+        private readonly IEventAggregator _eventAggregator;
+        private readonly IHostingEnvironment _hostingEnvironment;
 
         public CoreRuntime(
-            ILogger<CoreRuntime> logger,
+            ILoggerFactory loggerFactory,
             IRuntimeState state,
             ComponentCollection components,
             IApplicationShutdownRegistry applicationShutdownRegistry,
             IProfilingLogger profilingLogger,
             IMainDom mainDom,
-            IUmbracoDatabaseFactory databaseFactory)
+            IUmbracoDatabaseFactory databaseFactory,
+            IEventAggregator eventAggregator,
+            IHostingEnvironment hostingEnvironment)
         {
             State = state;
-            _logger = logger;
+            _loggerFactory = loggerFactory;
             _components = components;
             _applicationShutdownRegistry = applicationShutdownRegistry;
             _profilingLogger = profilingLogger;
             _mainDom = mainDom;
             _databaseFactory = databaseFactory;
-        }
-        
+            _eventAggregator = eventAggregator;
+            _hostingEnvironment = hostingEnvironment;
 
-        public void Start()
+
+            _logger = _loggerFactory.CreateLogger<CoreRuntime>();
+        }
+
+        /// <summary>
+        /// Gets the state of the Umbraco runtime.
+        /// </summary>
+        public IRuntimeState State { get; }
+
+        /// <inheritdoc/>
+        public async Task StartAsync(CancellationToken cancellationToken)
         {
+            StaticApplicationLogging.Initialize(_loggerFactory);
+
             AppDomain.CurrentDomain.UnhandledException += (_, args) =>
             {
                 var exception = (Exception)args.ExceptionObject;
                 var isTerminating = args.IsTerminating; // always true?
 
                 var msg = "Unhandled exception in AppDomain";
-                if (isTerminating) msg += " (terminating)";
+
+                if (isTerminating)
+                {
+                    msg += " (terminating)";
+                }
+
                 msg += ".";
+
                 _logger.LogError(exception, msg);
             };
 
+            AppDomain.CurrentDomain.SetData("DataDirectory", _hostingEnvironment?.MapPathContentRoot(Core.Constants.SystemDirectories.Data));
+
             DetermineRuntimeLevel();
 
             if (State.Level <= RuntimeLevel.BootFailed)
+            {
                 throw new InvalidOperationException($"Cannot start the runtime if the runtime level is less than or equal to {RuntimeLevel.BootFailed}");
+            }
 
-            var hostingEnvironmentLifetime = _applicationShutdownRegistry;
+            IApplicationShutdownRegistry hostingEnvironmentLifetime = _applicationShutdownRegistry;
             if (hostingEnvironmentLifetime == null)
-                throw new InvalidOperationException($"An instance of {typeof(IApplicationShutdownRegistry)} could not be resolved from the container, ensure that one if registered in your runtime before calling {nameof(IRuntime)}.{nameof(Start)}");
+            {
+                throw new InvalidOperationException($"An instance of {typeof(IApplicationShutdownRegistry)} could not be resolved from the container, ensure that one if registered in your runtime before calling {nameof(IRuntime)}.{nameof(StartAsync)}");
+            }
 
             // acquire the main domain - if this fails then anything that should be registered with MainDom will not operate
             AcquireMainDom();
 
+            await _eventAggregator.PublishAsync(new UmbracoApplicationStarting(State.Level), cancellationToken);
+
             // create & initialize the components
             _components.Initialize();
         }
 
-        public void Terminate()
+        public async Task StopAsync(CancellationToken cancellationToken)
         {
             _components.Terminate();
+            await _eventAggregator.PublishAsync(new UmbracoApplicationStopping(), cancellationToken);
+            StaticApplicationLogging.Initialize(null);
         }
 
         private void AcquireMainDom()
         {
-            using (var timer = _profilingLogger.DebugDuration<CoreRuntime>("Acquiring MainDom.", "Acquired."))
+            using (DisposableTimer timer = _profilingLogger.DebugDuration<CoreRuntime>("Acquiring MainDom.", "Acquired."))
             {
                 try
                 {
@@ -90,7 +124,7 @@ namespace Umbraco.Infrastructure.Runtime
 
         private void DetermineRuntimeLevel()
         {
-            using var timer = _profilingLogger.DebugDuration<CoreRuntime>("Determining runtime level.", "Determined.");
+            using DisposableTimer timer = _profilingLogger.DebugDuration<CoreRuntime>("Determining runtime level.", "Determined.");
 
             try
             {

src/Umbraco.Infrastructure/Runtime/EssentialDirectoryCreator.cs

@@ -1,25 +1,28 @@
-using Microsoft.Extensions.Options;
-using Umbraco.Core.Composing;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using Umbraco.Core;
 using Umbraco.Core.Configuration.Models;
+using Umbraco.Core.Events;
 using Umbraco.Core.Hosting;
 using Umbraco.Core.IO;
 
-namespace Umbraco.Core.Runtime
+namespace Umbraco.Infrastructure.Runtime
 {
-    public class CoreInitialComponent : IComponent
+    public class EssentialDirectoryCreator : INotificationHandler<UmbracoApplicationStarting>
     {
         private readonly IIOHelper _ioHelper;
         private readonly IHostingEnvironment _hostingEnvironment;
         private readonly GlobalSettings _globalSettings;
 
-        public CoreInitialComponent(IIOHelper ioHelper, IHostingEnvironment hostingEnvironment, IOptions<GlobalSettings> globalSettings)
+        public EssentialDirectoryCreator(IIOHelper ioHelper, IHostingEnvironment hostingEnvironment, IOptions<GlobalSettings> globalSettings)
         {
             _ioHelper = ioHelper;
             _hostingEnvironment = hostingEnvironment;
             _globalSettings = globalSettings.Value;
         }
 
-        public void Initialize()
+        public Task HandleAsync(UmbracoApplicationStarting notification, CancellationToken cancellationToken)
         {
             // ensure we have some essential directories
             // every other component can then initialize safely
@@ -28,9 +31,8 @@ namespace Umbraco.Core.Runtime
             _ioHelper.EnsurePathExists(_hostingEnvironment.MapPathContentRoot(Constants.SystemDirectories.MvcViews));
             _ioHelper.EnsurePathExists(_hostingEnvironment.MapPathContentRoot(Constants.SystemDirectories.PartialViews));
             _ioHelper.EnsurePathExists(_hostingEnvironment.MapPathContentRoot(Constants.SystemDirectories.MacroPartials));
-        }
 
-        public void Terminate()
-        { }
+            return Task.CompletedTask;
+        }
     }
 }