Scoped ModuleLoggerProvider.cs (#455)

* Scoped ModuleLoggerProvider.cs

* Update Initialisation library

* Fix

* Fix

* Fixes

Author: thomhurst

src/ModularPipelines.Build/ReleaseNotes.md

@@ -1,2 +1,2 @@
 *   Rework Dependency Injection Scopes (Singletons/Scoped services)
-*   Fix bug where the Interactive Progress Bar Console view isn't rendering
+*   Fix bug where the Interactive Progress Bar Console view was not rendering

src/ModularPipelines/DependencyInjection/DependencyInjectionSetup.cs

@@ -38,6 +38,7 @@ public static void Initialize(IServiceCollection services)
         // Everything that is injected into `PipelineContext` should be Scoped
         services
             .AddScoped<IPipelineContext, PipelineContext>()
+            .AddScoped<IModuleLoggerProvider, ModuleLoggerProvider>()
             .AddScoped(typeof(ModuleLogger<>))
             .AddScoped<IHttp, Http.Http>()
             .AddScoped<ICommand, Command>()
@@ -65,7 +66,6 @@ public static void Initialize(IServiceCollection services)
 
         // Singletons
         services
-            .AddSingleton<IModuleLoggerProvider, ModuleLoggerProvider>()
             .AddSingleton<IConsolePrinter, ConsolePrinter>()
             .AddSingleton<IPipelineContextProvider, ModuleContextProvider>()
             .AddSingleton<IDependencyChainProvider, DependencyChainProvider>()

src/ModularPipelines/Engine/Executors/ExecutionOrchestrator.cs

@@ -55,7 +55,7 @@ public async Task<PipelineSummary> ExecuteAsync(CancellationToken cancellationTo
         cancellationToken.Register(() => _engineCancellationToken.CancelWithReason("The user's cancellation token passed into the pipeline was cancelled."));
 
         var organizedModules = await _pipelineInitializer.Initialize();
-
+        
         var runnableModules = organizedModules.RunnableModules.Select(x => x.Module).ToList();
 
         var start = DateTimeOffset.UtcNow;
@@ -89,7 +89,7 @@ private async Task<PipelineSummary> ExecutePipeline(List<ModuleBase> runnableMod
         // Dispose and flush on scope leave - So including success or if an exception is thrown
         await using var moduleDisposeExecutor = _moduleDisposeExecutor;
         using var printModuleOutputExecutor = _printModuleOutputExecutor;
-        await using var printProgressExecutor = _printProgressExecutor;
+        await using var printProgressExecutor = await _printProgressExecutor.InitializeAsync();
 
         return await _pipelineExecutor.ExecuteAsync(runnableModules, organizedModules);
     }

src/ModularPipelines/Engine/Executors/IPrintProgressExecutor.cs

@@ -1,3 +1,6 @@
 namespace ModularPipelines.Engine.Executors;
 
-internal interface IPrintProgressExecutor : IAsyncDisposable;
+internal interface IPrintProgressExecutor : IAsyncDisposable
+{
+    Task<IPrintProgressExecutor> InitializeAsync();
+}

src/ModularPipelines/Engine/Executors/PrintProgressExecutor.cs

@@ -1,20 +1,19 @@
 using System.Diagnostics;
-using Initialization.Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using ModularPipelines.Helpers;
 
 namespace ModularPipelines.Engine.Executors;
 
 [StackTraceHidden]
-internal class PrintProgressExecutor : IPrintProgressExecutor, IInitializer
+internal class PrintProgressExecutor : IPrintProgressExecutor
 {
     private readonly EngineCancellationToken _engineCancellationToken;
     private readonly IConsolePrinter _consolePrinter;
     private readonly IModuleRetriever _moduleRetriever;
     private readonly ILogger<PrintProgressExecutor> _logger;
 
-    private Task _printProgressTask = null!; // LateInit
-    private CancellationTokenSource _printProgressCancellationTokenSource = null!; // LateInit
+    private Task? _printProgressTask;
+    private CancellationTokenSource? _printProgressCancellationTokenSource;
 
     public PrintProgressExecutor(EngineCancellationToken engineCancellationToken,
         IConsolePrinter consolePrinter,
@@ -26,10 +25,8 @@ public PrintProgressExecutor(EngineCancellationToken engineCancellationToken,
         _moduleRetriever = moduleRetriever;
         _logger = logger;
     }
-
-    public int Order => int.MaxValue;
-
-    public async Task InitializeAsync()
+    
+    public async Task<IPrintProgressExecutor> InitializeAsync()
     {
         _printProgressCancellationTokenSource =
             CancellationTokenSource.CreateLinkedTokenSource(_engineCancellationToken.Token);
@@ -38,11 +35,13 @@ public async Task InitializeAsync()
 
         _printProgressTask =
             _consolePrinter.PrintProgress(organizedModules, _printProgressCancellationTokenSource.Token);
+
+        return this;
     }
 
     public async ValueTask DisposeAsync()
     {
-        _printProgressCancellationTokenSource.CancelAfter(5000);
+        _printProgressCancellationTokenSource?.CancelAfter(5000);
 
         await SafelyAwaitProgressPrinter();
     }
@@ -51,7 +50,10 @@ private async Task SafelyAwaitProgressPrinter()
     {
         try
         {
-            await _printProgressTask;
+            if (_printProgressTask != null)
+            {
+                await _printProgressTask;
+            }
         }
         catch (Exception e)
         {

src/ModularPipelines/Engine/ModuleContextProvider.cs

@@ -1,12 +1,14 @@
 using Initialization.Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.DependencyInjection;
 using ModularPipelines.Context;
+using ModularPipelines.Interfaces;
 
 namespace ModularPipelines.Engine;
 
-internal class ModuleContextProvider : IPipelineContextProvider
+internal class ModuleContextProvider : IPipelineContextProvider, IScopeDisposer
 {
     private readonly IServiceProvider _serviceProvider;
+    private readonly List<IServiceScope> _scopes = new();
 
     public ModuleContextProvider(IServiceProvider serviceProvider)
     {
@@ -17,6 +19,13 @@ public IPipelineContext GetModuleContext()
     {
         var serviceScope = _serviceProvider.CreateAsyncScope();
 
+        _scopes.Add(serviceScope);
+        
         return serviceScope.ServiceProvider.GetRequiredService<IPipelineContext>();
     }
+
+    public IEnumerable<IServiceScope> GetScopes()
+    {
+        return _scopes;
+    }
 }

src/ModularPipelines/Engine/PipelineFileWriter.cs

@@ -5,17 +5,19 @@
 
 namespace ModularPipelines.Engine;
 
-internal class PipelineFileWriter : IPipelineFileWriter
+internal class PipelineFileWriter : IPipelineFileWriter, IScopeDisposer
 {
     private readonly IServiceProvider _serviceProvider;
     private readonly IPipelineContextProvider _pipelineContextProvider;
     private readonly IEnumerable<IBuildSystemPipelineFileWriter> _writers;
+    private readonly List<IServiceScope> _scopes = new();
 
     public PipelineFileWriter(IServiceProvider serviceProvider, IPipelineContextProvider pipelineContextProvider)
     {
         _serviceProvider = serviceProvider;
         _pipelineContextProvider = pipelineContextProvider;
         var scope = serviceProvider.CreateScope();
+        _scopes.Add(scope);
         _writers = scope.ServiceProvider.GetServices<IBuildSystemPipelineFileWriter>();
     }
 
@@ -27,4 +29,9 @@ await _writers
             )
             .ProcessInParallel();
     }
+
+    public IEnumerable<IServiceScope> GetScopes()
+    {
+        return _scopes;
+    }
 }

src/ModularPipelines/Engine/SafeModuleEstimatedTimeProvider.cs

@@ -1,19 +1,23 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using ModularPipelines.Interfaces;
 using ModularPipelines.Logging;
 using ModularPipelines.Models;
 
 namespace ModularPipelines.Engine;
 
-internal class SafeModuleEstimatedTimeProvider : ISafeModuleEstimatedTimeProvider
+internal class SafeModuleEstimatedTimeProvider : ISafeModuleEstimatedTimeProvider, IScopeDisposer
 {
     private readonly IModuleEstimatedTimeProvider _moduleEstimatedTimeProvider;
     private readonly ILogger _logger;
+    private readonly List<IServiceScope> _scopes = new();
 
-    public SafeModuleEstimatedTimeProvider(IModuleEstimatedTimeProvider moduleEstimatedTimeProvider,
-        IModuleLoggerProvider moduleLoggerProvider)
+    public SafeModuleEstimatedTimeProvider(IModuleEstimatedTimeProvider moduleEstimatedTimeProvider, IServiceProvider serviceProvider)
     {
         _moduleEstimatedTimeProvider = moduleEstimatedTimeProvider;
-        _logger = moduleLoggerProvider.GetLogger();
+        var scope = serviceProvider.CreateScope();
+        _scopes.Add(scope);
+        _logger = scope.ServiceProvider.GetRequiredService<IModuleLoggerProvider>().GetLogger();
     }
 
     public async Task<TimeSpan> GetModuleEstimatedTimeAsync(Type moduleType)
@@ -66,4 +70,9 @@ public async Task SaveSubModuleTimeAsync(Type moduleType, SubModuleEstimation su
             _logger.LogWarning(e, "Error saving submodule execution time for {Module}", moduleType.Name);
         }
     }
+
+    public IEnumerable<IServiceScope> GetScopes()
+    {
+        return _scopes;
+    }
 }

src/ModularPipelines/Interfaces/IScopeDisposer.cs

@@ -0,0 +1,16 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace ModularPipelines.Interfaces;
+
+public interface IScopeDisposer : IDisposable
+{
+    IEnumerable<IServiceScope> GetScopes();
+    
+    void IDisposable.Dispose()
+    {
+        foreach (var serviceScope in GetScopes())
+        {
+            serviceScope.Dispose();
+        }
+    }
+}

src/ModularPipelines/Logging/IModuleLoggerContainer.cs

@@ -4,5 +4,7 @@ internal interface IModuleLoggerContainer
 {
     void PrintAllLoggers();
 
+    IModuleLogger? GetLogger(Type type);
+
     void AddLogger(ModuleLogger logger);
 }