Merge pull request #7 from candoumbe/feature/add-cancellation-token-support

thomaslevesque · web-flow · commit 4820a0c9d831 · 2023-04-04T21:30:25.000-04:00
feat(hosting) : add cancellation token support
diff --git a/README.md b/README.md
@@ -35,7 +35,7 @@ A simple helper to perform async application initialization for the generic host
             ...
         }
 
-        public async Task InitializeAsync()
+        public async Task InitializeAsync(CancellationToken cancellationToken)
         {
             // Initialization code here
         }
@@ -59,6 +59,25 @@ A simple helper to perform async application initialization for the generic host
     }
     ```
 
+    You can also pass a `CancellationToken` in order to propagate notifications to cancel the initialization if needed.
+
+    In the following example, the initialization will be cancelled when `Ctrl + C` keys are pressed :
+    ```csharp
+    public static async Task Main(string[] args)
+    {
+        using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+
+        // The following line will hook `Ctrl` + `C` to the cancellation token. 
+        Console.CancelKeyPress += (source, args) => cancellationTokenSource.Cancel();
+
+        var host = CreateHostBuilder(args).Build();
+
+        await host.InitAsync(cancellationTokenSource.Token);
+        await host.RunAsync();
+    }
+    ```
+
+
 (Note that you need to [set the C# language version to 7.1 or higher in your project](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/configure-language-version#edit-the-csproj-file) to enable the "async Main" feature.)
 
 This will run each initializer, in the order in which they were registered.
diff --git a/src/Extensions.Hosting.AsyncInitialization/DependencyInjection/AsyncInitializationServiceCollectionExtensions.cs b/src/Extensions.Hosting.AsyncInitialization/DependencyInjection/AsyncInitializationServiceCollectionExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Extensions.Hosting.AsyncInitialization;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -96,6 +97,22 @@ public static IServiceCollection AddAsyncInitializer(this IServiceCollection ser
         /// <param name="initializer">The delegate that performs async initialization.</param>
         /// <returns>A reference to this instance after the operation has completed.</returns>
         public static IServiceCollection AddAsyncInitializer(this IServiceCollection services, Func<Task> initializer)
+        {
+            if (initializer == null)
+                throw new ArgumentNullException(nameof(initializer));
+
+            return services
+                .AddAsyncInitialization()
+                .AddSingleton<IAsyncInitializer>(new DelegateAsyncInitializer(_ => initializer()));
+        }
+
+        /// <summary>
+        /// Adds an async initializer whose implementation is the specified delegate.
+        /// </summary>
+        /// <param name="services">The <see cref="T:Microsoft.Extensions.DependencyInjection.IServiceCollection" /> to add the service to.</param>
+        /// <param name="initializer">The delegate that performs async initialization.</param>
+        /// <returns>A reference to this instance after the operation has completed.</returns>
+        public static IServiceCollection AddAsyncInitializer(this IServiceCollection services, Func<CancellationToken, Task> initializer)
         {
             if (initializer == null)
                 throw new ArgumentNullException(nameof(initializer));
@@ -107,16 +124,16 @@ public static IServiceCollection AddAsyncInitializer(this IServiceCollection ser
 
         private class DelegateAsyncInitializer : IAsyncInitializer
         {
-            private readonly Func<Task> _initializer;
+            private readonly Func<CancellationToken, Task> _initializer;
 
-            public DelegateAsyncInitializer(Func<Task> initializer)
+            public DelegateAsyncInitializer(Func<CancellationToken, Task> initializer)
             {
                 _initializer = initializer;
             }
 
-            public Task InitializeAsync()
+            public Task InitializeAsync(CancellationToken cancellationToken)
             {
-                return _initializer();
+                return _initializer(cancellationToken);
             }
         }
     }
diff --git a/src/Extensions.Hosting.AsyncInitialization/Extensions.Hosting.AsyncInitialization.csproj b/src/Extensions.Hosting.AsyncInitialization/Extensions.Hosting.AsyncInitialization.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <LangVersion>8.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <Authors>Thomas Levesque</Authors>
     <Title>.NET Core generic host async initialization</Title>
diff --git a/src/Extensions.Hosting.AsyncInitialization/Hosting/AsyncInitializationHostExtensions.cs b/src/Extensions.Hosting.AsyncInitialization/Hosting/AsyncInitializationHostExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Extensions.Hosting.AsyncInitialization;
 using Microsoft.Extensions.DependencyInjection;
@@ -15,22 +16,21 @@ public static class AsyncInitializationHostExtensions
         /// Initializes the application, by calling all registered async initializers.
         /// </summary>
         /// <param name="host">The host.</param>
+        /// <param name="cancellationToken">Optionally propagates notifications that the operation should be cancelled</param>
         /// <returns>A task that represents the initialization completion.</returns>
-        public static async Task InitAsync(this IHost host)
+        public static async Task InitAsync(this IHost host, CancellationToken cancellationToken = default)
         {
             if (host == null)
                 throw new ArgumentNullException(nameof(host));
 
-            using (var scope = host.Services.CreateScope())
+            using var scope = host.Services.CreateScope();
+            var rootInitializer = scope.ServiceProvider.GetService<RootInitializer?>();
+            if (rootInitializer == null)
             {
-                var rootInitializer = scope.ServiceProvider.GetService<RootInitializer?>();
-                if (rootInitializer == null)
-                {
-                    throw new InvalidOperationException("The async initialization service isn't registered, register it by calling AddAsyncInitialization() on the service collection or by adding an async initializer.");
-                }
-
-                await rootInitializer.InitializeAsync();
+                throw new InvalidOperationException("The async initialization service isn't registered, register it by calling AddAsyncInitialization() on the service collection or by adding an async initializer.");
             }
+
+            await rootInitializer.InitializeAsync(cancellationToken);
         }
     }
-}
+}
diff --git a/src/Extensions.Hosting.AsyncInitialization/IAsyncInitializer.cs b/src/Extensions.Hosting.AsyncInitialization/IAsyncInitializer.cs
@@ -1,4 +1,5 @@
-﻿using System.Threading.Tasks;
+﻿using System.Threading;
+using System.Threading.Tasks;
 
 namespace Extensions.Hosting.AsyncInitialization
 {
@@ -10,7 +11,8 @@ public interface IAsyncInitializer
         /// <summary>
         /// Performs async initialization.
         /// </summary>
+        /// <param name="cancellationToken">Notifies that the operation should be cancelled</param>
         /// <returns>A task that represents the initialization completion.</returns>
-        Task InitializeAsync();
+        Task InitializeAsync(CancellationToken cancellationToken);
     }
 }
diff --git a/src/Extensions.Hosting.AsyncInitialization/RootInitializer.cs b/src/Extensions.Hosting.AsyncInitialization/RootInitializer.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 
@@ -16,18 +17,19 @@ public RootInitializer(ILogger<RootInitializer> logger, IEnumerable<IAsyncInitia
             _initializers = initializers;
         }
 
-        public async Task InitializeAsync()
+        public async Task InitializeAsync(CancellationToken cancellationToken = default)
         {
             _logger.LogInformation("Starting async initialization");
 
             try
             {
                 foreach (var initializer in _initializers)
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
                     _logger.LogInformation("Starting async initialization for {InitializerType}", initializer.GetType());
                     try
                     {
-                        await initializer.InitializeAsync();
+                        await initializer.InitializeAsync(cancellationToken);
                         _logger.LogInformation("Async initialization for {InitializerType} completed", initializer.GetType());
                     }
                     catch (Exception ex)
@@ -39,7 +41,12 @@ public async Task InitializeAsync()
 
                 _logger.LogInformation("Async initialization completed");
             }
-            catch(Exception ex)
+            catch (OperationCanceledException)
+            {
+                _logger.LogWarning("Async initialization cancelled");
+                throw;
+            }
+            catch (Exception ex)
             {
                 _logger.LogError(ex, "Async initialization failed");
                 throw;
diff --git a/tests/Extensions.Hosting.AsyncInitialization.Tests/AsyncInitializationTests.cs b/tests/Extensions.Hosting.AsyncInitialization.Tests/AsyncInitializationTests.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Threading;
 using System.Threading.Tasks;
 using FakeItEasy;
 using Microsoft.Extensions.DependencyInjection;
@@ -18,19 +19,19 @@ public async Task Single_initializer_is_called()
 
             await host.InitAsync();
 
-            A.CallTo(() => initializer.InitializeAsync()).MustHaveHappenedOnceExactly();
+            A.CallTo(() => initializer.InitializeAsync(CancellationToken.None)).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
         public async Task Delegate_initializer_is_called()
         {
-            var initializer = A.Fake<Func<Task>>();
+            var initializer = A.Fake<Func<CancellationToken, Task>>();
 
             var host = CreateHost(services => services.AddAsyncInitializer(initializer));
 
             await host.InitAsync();
 
-            A.CallTo(() => initializer()).MustHaveHappenedOnceExactly();
+            A.CallTo(() => initializer(CancellationToken.None)).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
@@ -49,9 +50,9 @@ public async Task Multiple_initializers_are_called_in_order()
 
             await host.InitAsync();
 
-            A.CallTo(() => initializer1.InitializeAsync()).MustHaveHappenedOnceExactly()
-                .Then(A.CallTo(() => initializer2.InitializeAsync()).MustHaveHappenedOnceExactly())
-                .Then(A.CallTo(() => initializer3.InitializeAsync()).MustHaveHappenedOnceExactly());
+            A.CallTo(() => initializer1.InitializeAsync(default)).MustHaveHappenedOnceExactly()
+                .Then(A.CallTo(() => initializer2.InitializeAsync(default)).MustHaveHappenedOnceExactly())
+                .Then(A.CallTo(() => initializer3.InitializeAsync(default)).MustHaveHappenedOnceExactly());
         }
 
         [Fact]
@@ -75,7 +76,7 @@ public async Task Failing_initializer_makes_initialization_fail()
             var initializer2 = A.Fake<IAsyncInitializer>();
             var initializer3 = A.Fake<IAsyncInitializer>();
 
-            A.CallTo(() => initializer2.InitializeAsync()).ThrowsAsync(() => new Exception("oops"));
+            A.CallTo(() => initializer2.InitializeAsync(default)).ThrowsAsync(() => new Exception("oops"));
 
             var host = CreateHost(services =>
             {
@@ -88,8 +89,34 @@ public async Task Failing_initializer_makes_initialization_fail()
             Assert.IsType<Exception>(exception);
             Assert.Equal("oops", exception.Message);
 
-            A.CallTo(() => initializer1.InitializeAsync()).MustHaveHappenedOnceExactly();
-            A.CallTo(() => initializer3.InitializeAsync()).MustNotHaveHappened();
+            A.CallTo(() => initializer1.InitializeAsync(default)).MustHaveHappenedOnceExactly();
+            A.CallTo(() => initializer3.InitializeAsync(default)).MustNotHaveHappened();
+        }
+
+        [Fact]
+        public async Task Cancelled_initializer_makes_initialization_fail()
+        {
+            using var cancellationTokenSource = new CancellationTokenSource();
+            var initializer1 = A.Fake<IAsyncInitializer>();
+            var initializer2 = A.Fake<IAsyncInitializer>();
+            var initializer3 = A.Fake<IAsyncInitializer>();
+
+
+            A.CallTo(() => initializer1.InitializeAsync(A<CancellationToken>._)).Invokes(_ => cancellationTokenSource.Cancel());
+
+            var host = CreateHost(services =>
+            {
+                services.AddAsyncInitializer(initializer1);
+                services.AddAsyncInitializer(initializer2);
+                services.AddAsyncInitializer(initializer3);
+            });
+
+            var exception = await Record.ExceptionAsync(() => host.InitAsync(cancellationTokenSource.Token));
+            Assert.IsType<OperationCanceledException>(exception);
+            
+            A.CallTo(() => initializer1.InitializeAsync(A<CancellationToken>._)).MustHaveHappenedOnceExactly();
+            A.CallTo(() => initializer2.InitializeAsync(A<CancellationToken>._)).MustNotHaveHappened();
+            A.CallTo(() => initializer3.InitializeAsync(A<CancellationToken>._)).MustNotHaveHappened();
         }
 
         [Fact]
@@ -125,7 +152,8 @@ public Initializer(IDependency dependency)
             {
                 _dependency = dependency;
             }
-            public Task InitializeAsync() => Task.CompletedTask;
+
+            public Task InitializeAsync(CancellationToken cancellationToken) => Task.CompletedTask;
         }
     }
 }
diff --git a/tests/Extensions.Hosting.AsyncInitialization.Tests/Extensions.Hosting.AsyncInitialization.Tests.csproj b/tests/Extensions.Hosting.AsyncInitialization.Tests/Extensions.Hosting.AsyncInitialization.Tests.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>netcoreapp3.0;netcoreapp2.1;net471</TargetFrameworks>
-    <LangVersion>8.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
     <MSEHostingVersion Condition="'$(TargetFramework)' == 'netcoreapp2.1'">2.1.0</MSEHostingVersion>

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.Threading.Tasks;`
	`1`	`+using System.Threading;`
	`2`	`+using System.Threading.Tasks;`
`2`	`3`
`3`	`4`	`namespace Extensions.Hosting.AsyncInitialization`
`4`	`5`	`{`
`@@ -10,7 +11,8 @@ public interface IAsyncInitializer`
`10`	`11`	`/// <summary>`
`11`	`12`	`/// Performs async initialization.`
`12`	`13`	`/// </summary>`
	`14`	`+ /// <param name="cancellationToken">Notifies that the operation should be cancelled</param>`
`13`	`15`	`/// <returns>A task that represents the initialization completion.</returns>`
`14`		`- Task InitializeAsync();`
	`16`	`+ Task InitializeAsync(CancellationToken cancellationToken);`
`15`	`17`	`}`
`16`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Threading;`
`3`	`4`	`using System.Threading.Tasks;`
`4`	`5`	`using Microsoft.Extensions.Logging;`
`5`	`6`
`@@ -16,18 +17,19 @@ public RootInitializer(ILogger<RootInitializer> logger, IEnumerable<IAsyncInitia`
`16`	`17`	`_initializers = initializers;`
`17`	`18`	`}`
`18`	`19`
`19`		`- public async Task InitializeAsync()`
	`20`	`+ public async Task InitializeAsync(CancellationToken cancellationToken = default)`
`20`	`21`	`{`
`21`	`22`	`_logger.LogInformation("Starting async initialization");`
`22`	`23`
`23`	`24`	`try`
`24`	`25`	`{`
`25`	`26`	`foreach (var initializer in _initializers)`
`26`	`27`	`{`
	`28`	`+ cancellationToken.ThrowIfCancellationRequested();`
`27`	`29`	`_logger.LogInformation("Starting async initialization for {InitializerType}", initializer.GetType());`
`28`	`30`	`try`
`29`	`31`	`{`
`30`		`- await initializer.InitializeAsync();`
	`32`	`+ await initializer.InitializeAsync(cancellationToken);`
`31`	`33`	`_logger.LogInformation("Async initialization for {InitializerType} completed", initializer.GetType());`
`32`	`34`	`}`
`33`	`35`	`catch (Exception ex)`
`@@ -39,7 +41,12 @@ public async Task InitializeAsync()`
`39`	`41`
`40`	`42`	`_logger.LogInformation("Async initialization completed");`
`41`	`43`	`}`
`42`		`- catch(Exception ex)`
	`44`	`+ catch (OperationCanceledException)`
	`45`	`+ {`
	`46`	`+ _logger.LogWarning("Async initialization cancelled");`
	`47`	`+ throw;`
	`48`	`+ }`
	`49`	`+ catch (Exception ex)`
`43`	`50`	`{`
`44`	`51`	`_logger.LogError(ex, "Async initialization failed");`
`45`	`52`	`throw;`