Optimize CancellationToken handling (#51660)

pentp · web-flow · commit 89c2ef34b30f · 2023-11-01T12:58:24.000-07:00
diff --git a/src/Hosting/Hosting/src/GenericHost/GenericWebHostBuilder.cs b/src/Hosting/Hosting/src/GenericHost/GenericWebHostBuilder.cs
@@ -324,7 +324,7 @@ public IWebHostBuilder Configure(Action<IApplicationBuilder> configure)
             {
                 services.Configure<GenericWebHostServiceOptions>(options =>
                 {
-                    options.ConfigureApplication = app => configure(app);
+                    options.ConfigureApplication = configure;
                 });
             }
         });
diff --git a/src/Hosting/Hosting/src/Internal/ApplicationLifetime.cs b/src/Hosting/Hosting/src/Internal/ApplicationLifetime.cs
@@ -58,7 +58,7 @@ public void StopApplication()
         {
             try
             {
-                ExecuteHandlers(_stoppingSource);
+                _stoppingSource.Cancel();
             }
             catch (Exception ex)
             {
@@ -76,7 +76,7 @@ public void NotifyStarted()
     {
         try
         {
-            ExecuteHandlers(_startedSource);
+            _startedSource.Cancel();
         }
         catch (Exception ex)
         {
@@ -93,7 +93,7 @@ public void NotifyStopped()
     {
         try
         {
-            ExecuteHandlers(_stoppedSource);
+            _stoppedSource.Cancel();
         }
         catch (Exception ex)
         {
@@ -102,16 +102,4 @@ public void NotifyStopped()
                                      ex);
         }
     }
-
-    private static void ExecuteHandlers(CancellationTokenSource cancel)
-    {
-        // Noop if this is already cancelled
-        if (cancel.IsCancellationRequested)
-        {
-            return;
-        }
-
-        // Run the cancellation token callbacks
-        cancel.Cancel(throwOnFirstException: false);
-    }
 }
diff --git a/src/Hosting/Hosting/src/Internal/HostedServiceExecutor.cs b/src/Hosting/Hosting/src/Internal/HostedServiceExecutor.cs
@@ -2,53 +2,39 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Hosting;
 
 internal sealed class HostedServiceExecutor
 {
     private readonly IEnumerable<IHostedService> _services;
-    private readonly ILogger<HostedServiceExecutor> _logger;
 
-    public HostedServiceExecutor(ILogger<HostedServiceExecutor> logger, IEnumerable<IHostedService> services)
+    public HostedServiceExecutor(IEnumerable<IHostedService> services)
     {
-        _logger = logger;
         _services = services;
     }
 
-    public Task StartAsync(CancellationToken token)
+    public async Task StartAsync(CancellationToken token)
     {
-        return ExecuteAsync(service => service.StartAsync(token));
-    }
-
-    public Task StopAsync(CancellationToken token)
-    {
-        return ExecuteAsync(service => service.StopAsync(token), throwOnFirstFailure: false);
+        foreach (var service in _services)
+        {
+            await service.StartAsync(token);
+        }
     }
 
-    private async Task ExecuteAsync(Func<IHostedService, Task> callback, bool throwOnFirstFailure = true)
+    public async Task StopAsync(CancellationToken token)
     {
         List<Exception>? exceptions = null;
 
         foreach (var service in _services)
         {
             try
             {
-                await callback(service);
+                await service.StopAsync(token);
             }
             catch (Exception ex)
             {
-                if (throwOnFirstFailure)
-                {
-                    throw;
-                }
-
-                if (exceptions == null)
-                {
-                    exceptions = new List<Exception>();
-                }
-
+                exceptions ??= [];
                 exceptions.Add(ex);
             }
         }
diff --git a/src/Hosting/Hosting/src/Internal/WebHost.cs b/src/Hosting/Hosting/src/Internal/WebHost.cs
@@ -286,16 +286,9 @@ public async Task StopAsync(CancellationToken cancellationToken = default)
 
         Log.Shutdown(_logger);
 
-        using var timeoutCTS = new CancellationTokenSource(Options.ShutdownTimeout);
-        var timeoutToken = timeoutCTS.Token;
-        if (!cancellationToken.CanBeCanceled)
-        {
-            cancellationToken = timeoutToken;
-        }
-        else
-        {
-            cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutToken).Token;
-        }
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        cts.CancelAfter(Options.ShutdownTimeout);
+        cancellationToken = cts.Token;
 
         // Fire IApplicationLifetime.Stopping
         _applicationLifetime?.StopApplication();
@@ -340,17 +333,17 @@ public async ValueTask DisposeAsync()
         await DisposeServiceProviderAsync(_hostingServiceProvider).ConfigureAwait(false);
     }
 
-    private static async ValueTask DisposeServiceProviderAsync(IServiceProvider? serviceProvider)
+    private static ValueTask DisposeServiceProviderAsync(IServiceProvider? serviceProvider)
     {
         switch (serviceProvider)
         {
             case IAsyncDisposable asyncDisposable:
-                await asyncDisposable.DisposeAsync().ConfigureAwait(false);
-                break;
+                return asyncDisposable.DisposeAsync();
             case IDisposable disposable:
                 disposable.Dispose();
                 break;
         }
+        return default;
     }
 
     private static partial class Log
diff --git a/src/Hosting/Hosting/src/Startup/ConventionBasedStartup.cs b/src/Hosting/Hosting/src/Startup/ConventionBasedStartup.cs
@@ -23,13 +23,9 @@ public void Configure(IApplicationBuilder app)
         {
             _methods.ConfigureDelegate(app);
         }
-        catch (Exception ex)
+        catch (TargetInvocationException ex)
         {
-            if (ex is TargetInvocationException)
-            {
-                ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();
-            }
-
+            ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();
             throw;
         }
     }
@@ -40,13 +36,9 @@ public IServiceProvider ConfigureServices(IServiceCollection services)
         {
             return _methods.ConfigureServicesDelegate(services);
         }
-        catch (Exception ex)
+        catch (TargetInvocationException ex)
         {
-            if (ex is TargetInvocationException)
-            {
-                ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();
-            }
-
+            ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();
             throw;
         }
     }
diff --git a/src/Hosting/Hosting/src/WebHostBuilderExtensions.cs b/src/Hosting/Hosting/src/WebHostBuilderExtensions.cs
@@ -46,7 +46,7 @@ public static IWebHostBuilder Configure(this IWebHostBuilder hostBuilder, Action
         {
             services.AddSingleton<IStartup>(sp =>
             {
-                return new DelegateStartup(sp.GetRequiredService<IServiceProviderFactory<IServiceCollection>>(), (app => configureApp(app)));
+                return new DelegateStartup(sp.GetRequiredService<IServiceProviderFactory<IServiceCollection>>(), configureApp);
             });
         });
     }
diff --git a/src/Hosting/Hosting/src/WebHostExtensions.cs b/src/Hosting/Hosting/src/WebHostExtensions.cs
@@ -159,14 +159,8 @@ private static async Task WaitForTokenShutdownAsync(this IWebHost host, Cancella
         },
         applicationLifetime);
 
-        var waitForStop = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
-        applicationLifetime.ApplicationStopping.Register(obj =>
-        {
-            var tcs = (TaskCompletionSource)obj!;
-            tcs.TrySetResult();
-        }, waitForStop);
-
-        await waitForStop.Task;
+        await Task.Delay(Timeout.Infinite, applicationLifetime.ApplicationStopping)
+            .ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing | ConfigureAwaitOptions.ContinueOnCapturedContext);
 
         // WebHost will use its default ShutdownTimeout if none is specified.
 #pragma warning disable CA2016 // Forward the 'CancellationToken' parameter to methods. StopAsync should not be canceled by the token to RunAsync.
diff --git a/src/Http/Http/src/Timeouts/RequestTimeoutsMiddleware.cs b/src/Http/Http/src/Timeouts/RequestTimeoutsMiddleware.cs
@@ -107,10 +107,9 @@ async Task SetTimeoutAsync()
                 await _next(context);
             }
             catch (OperationCanceledException operationCanceledException)
+            when (linkedCts.IsCancellationRequested && !originalToken.IsCancellationRequested)
             {
-                if (context.Response.HasStarted ||
-                    !linkedCts.Token.IsCancellationRequested ||
-                    originalToken.IsCancellationRequested)
+                if (context.Response.HasStarted)
                 {
                     // We can't produce a response, or it wasn't our timeout that caused this.
                     throw;
diff --git a/src/Middleware/Session/src/DistributedSession.cs b/src/Middleware/Session/src/DistributedSession.cs
@@ -218,9 +218,9 @@ public async Task LoadAsync(CancellationToken cancellationToken = default)
         // This will throw if called directly and a failure occurs. The user is expected to handle the failures.
         if (!_loaded)
         {
-            using (var timeout = new CancellationTokenSource(_ioTimeout))
+            using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
             {
-                var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);
+                cts.CancelAfter(_ioTimeout);
                 try
                 {
                     cts.Token.ThrowIfCancellationRequested();
@@ -234,14 +234,10 @@ public async Task LoadAsync(CancellationToken cancellationToken = default)
                         _logger.AccessingExpiredSession(_sessionKey);
                     }
                 }
-                catch (OperationCanceledException oex)
+                catch (OperationCanceledException oex) when (!cancellationToken.IsCancellationRequested && cts.IsCancellationRequested)
                 {
-                    if (timeout.Token.IsCancellationRequested)
-                    {
-                        _logger.SessionLoadingTimeout();
-                        throw new OperationCanceledException("Timed out loading the session.", oex, timeout.Token);
-                    }
-                    throw;
+                    _logger.SessionLoadingTimeout();
+                    throw new OperationCanceledException("Timed out loading the session.", oex, cts.Token);
                 }
             }
             _isAvailable = true;
@@ -252,9 +248,9 @@ public async Task LoadAsync(CancellationToken cancellationToken = default)
     /// <inheritdoc />
     public async Task CommitAsync(CancellationToken cancellationToken = default)
     {
-        using (var timeout = new CancellationTokenSource(_ioTimeout))
+        using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
         {
-            var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);
+            cts.CancelAfter(_ioTimeout);
             if (_isModified)
             {
                 if (_logger.IsEnabled(LogLevel.Information))
@@ -293,14 +289,10 @@ await _cache.SetAsync(
                     _isModified = false;
                     _logger.SessionStored(_sessionKey, Id, _store.Count);
                 }
-                catch (OperationCanceledException oex)
+                catch (OperationCanceledException oex) when (!cancellationToken.IsCancellationRequested && cts.IsCancellationRequested)
                 {
-                    if (timeout.Token.IsCancellationRequested)
-                    {
-                        _logger.SessionCommitTimeout();
-                        throw new OperationCanceledException("Timed out committing the session.", oex, timeout.Token);
-                    }
-                    throw;
+                    _logger.SessionCommitTimeout();
+                    throw new OperationCanceledException("Timed out committing the session.", oex, cts.Token);
                 }
             }
             else
@@ -309,14 +301,10 @@ await _cache.SetAsync(
                 {
                     await _cache.RefreshAsync(_sessionKey, cts.Token);
                 }
-                catch (OperationCanceledException oex)
+                catch (OperationCanceledException oex) when (!cancellationToken.IsCancellationRequested && cts.IsCancellationRequested)
                 {
-                    if (timeout.Token.IsCancellationRequested)
-                    {
-                        _logger.SessionRefreshTimeout();
-                        throw new OperationCanceledException("Timed out refreshing the session.", oex, timeout.Token);
-                    }
-                    throw;
+                    _logger.SessionRefreshTimeout();
+                    throw new OperationCanceledException("Timed out refreshing the session.", oex, cts.Token);
                 }
             }
         }
diff --git a/src/Middleware/Spa/SpaProxy/src/SpaProxyLaunchManager.cs b/src/Middleware/Spa/SpaProxy/src/SpaProxyLaunchManager.cs
@@ -74,8 +74,8 @@ public async Task<bool> IsSpaProxyRunning(CancellationToken cancellationToken)
     {
         var httpClient = CreateHttpClient();
 
-        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-        using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);
+        using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10));
         try
         {
             var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);
@@ -105,8 +105,8 @@ private static HttpClient CreateHttpClient()
 
     private async Task<bool> ProbeSpaDevelopmentServerUrl(HttpClient httpClient, CancellationToken cancellationToken)
     {
-        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-        using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);
+        using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10));
         try
         {
             var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);
diff --git a/src/Servers/Kestrel/Core/src/Internal/AddressBinder.cs b/src/Servers/Kestrel/Core/src/Internal/AddressBinder.cs
@@ -16,7 +16,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal;
 internal sealed class AddressBinder
 {
     // note this doesn't copy the ListenOptions[], only call this with an array that isn't mutated elsewhere
-    public static async Task BindAsync(ListenOptions[] listenOptions, AddressBindContext context, Func<ListenOptions, ListenOptions> useHttps, CancellationToken cancellationToken)
+    public static Task BindAsync(ListenOptions[] listenOptions, AddressBindContext context, Func<ListenOptions, ListenOptions> useHttps, CancellationToken cancellationToken)
     {
         var strategy = CreateStrategy(
             listenOptions,
@@ -29,7 +29,7 @@ public static async Task BindAsync(ListenOptions[] listenOptions, AddressBindCon
         context.ServerOptions.OptionsInUse.Clear();
         context.Addresses.Clear();
 
-        await strategy.BindAsync(context, cancellationToken).ConfigureAwait(false);
+        return strategy.BindAsync(context, cancellationToken);
     }
 
     private static IStrategy CreateStrategy(ListenOptions[] listenOptions, string[] addresses, bool preferAddresses, Func<ListenOptions, ListenOptions> useHttps)
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/Http1Connection.cs b/src/Servers/Kestrel/Core/src/Internal/Http/Http1Connection.cs
@@ -699,12 +699,9 @@ protected override bool TryParseRequest(ReadResult result, out bool endConnectio
         {
             isConsumed = ParseRequest(ref reader);
         }
-        catch (InvalidOperationException)
+        catch (InvalidOperationException) when (_requestProcessingStatus == RequestProcessingStatus.ParsingHeaders)
         {
-            if (_requestProcessingStatus == RequestProcessingStatus.ParsingHeaders)
-            {
-                KestrelBadHttpRequestException.Throw(RequestRejectionReason.MalformedRequestInvalidHeaders);
-            }
+            KestrelBadHttpRequestException.Throw(RequestRejectionReason.MalformedRequestInvalidHeaders);
             throw;
         }
 #pragma warning disable CS0618 // Type or member is obsolete
diff --git a/src/Servers/Kestrel/Core/src/Internal/KestrelServerImpl.cs b/src/Servers/Kestrel/Core/src/Internal/KestrelServerImpl.cs
@@ -354,8 +354,8 @@ private async Task RebindAsync()
                 }
 
                 // 5 is the default value for WebHost's "shutdownTimeoutSeconds", so use that.
-                using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-                using var combinedCts = CancellationTokenSource.CreateLinkedTokenSource(_stopCts.Token, timeoutCts.Token);
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(_stopCts.Token);
+                cts.CancelAfter(TimeSpan.FromSeconds(5));
 
                 // TODO: It would be nice to start binding to new endpoints immediately and reconfigured endpoints as soon
                 // as the unbinding finished for the given endpoint rather than wait for all transports to unbind first.
@@ -364,7 +364,7 @@ private async Task RebindAsync()
                 {
                     configsToStop.Add(lo.EndpointConfig!);
                 }
-                await _transportManager.StopEndpointsAsync(configsToStop, combinedCts.Token).ConfigureAwait(false);
+                await _transportManager.StopEndpointsAsync(configsToStop, cts.Token).ConfigureAwait(false);
 
                 foreach (var listenOption in endpointsToStop)
                 {
diff --git a/src/Servers/Kestrel/Core/src/Middleware/HttpsConnectionMiddleware.cs b/src/Servers/Kestrel/Core/src/Middleware/HttpsConnectionMiddleware.cs
@@ -259,15 +259,10 @@ private X509Certificate2 LocateCertificateWithPrivateKey(X509Certificate2 certif
                 store.Open(OpenFlags.ReadOnly);
                 return store;
             }
-            catch (Exception exception)
+            catch (Exception exception) when (exception is CryptographicException || exception is SecurityException)
             {
-                if (exception is CryptographicException || exception is SecurityException)
-                {
-                    _logger.FailedToOpenStore(storeLocation, exception);
-                    return null;
-                }
-
-                throw;
+                _logger.FailedToOpenStore(storeLocation, exception);
+                return null;
             }
         }
 
diff --git a/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionContext.cs b/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionContext.cs

Original file line number	Diff line number	Diff line change
`@@ -324,7 +324,7 @@ public IWebHostBuilder Configure(Action<IApplicationBuilder> configure)`
`324`	`324`	`{`
`325`	`325`	`services.Configure<GenericWebHostServiceOptions>(options =>`
`326`	`326`	`{`
`327`		`- options.ConfigureApplication = app => configure(app);`
	`327`	`+ options.ConfigureApplication = configure;`
`328`	`328`	`});`
`329`	`329`	`}`
`330`	`330`	`});`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public void StopApplication()`
`58`	`58`	`{`
`59`	`59`	`try`
`60`	`60`	`{`
`61`		`- ExecuteHandlers(_stoppingSource);`
	`61`	`+ _stoppingSource.Cancel();`
`62`	`62`	`}`
`63`	`63`	`catch (Exception ex)`
`64`	`64`	`{`
`@@ -76,7 +76,7 @@ public void NotifyStarted()`
`76`	`76`	`{`
`77`	`77`	`try`
`78`	`78`	`{`
`79`		`- ExecuteHandlers(_startedSource);`
	`79`	`+ _startedSource.Cancel();`
`80`	`80`	`}`
`81`	`81`	`catch (Exception ex)`
`82`	`82`	`{`
`@@ -93,7 +93,7 @@ public void NotifyStopped()`
`93`	`93`	`{`
`94`	`94`	`try`
`95`	`95`	`{`
`96`		`- ExecuteHandlers(_stoppedSource);`
	`96`	`+ _stoppedSource.Cancel();`
`97`	`97`	`}`
`98`	`98`	`catch (Exception ex)`
`99`	`99`	`{`
`@@ -102,16 +102,4 @@ public void NotifyStopped()`
`102`	`102`	`ex);`
`103`	`103`	`}`
`104`	`104`	`}`
`105`		`-`
`106`		`- private static void ExecuteHandlers(CancellationTokenSource cancel)`
`107`		`- {`
`108`		`- // Noop if this is already cancelled`
`109`		`- if (cancel.IsCancellationRequested)`
`110`		`- {`
`111`		`- return;`
`112`		`- }`
`113`		`-`
`114`		`- // Run the cancellation token callbacks`
`115`		`- cancel.Cancel(throwOnFirstException: false);`
`116`		`- }`
`117`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,53 +2,39 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`	`4`	`using Microsoft.Extensions.Hosting;`
`5`		`-using Microsoft.Extensions.Logging;`
`6`	`5`
`7`	`6`	`namespace Microsoft.AspNetCore.Hosting;`
`8`	`7`
`9`	`8`	`internal sealed class HostedServiceExecutor`
`10`	`9`	`{`
`11`	`10`	`private readonly IEnumerable<IHostedService> _services;`
`12`		`- private readonly ILogger<HostedServiceExecutor> _logger;`
`13`	`11`
`14`		`- public HostedServiceExecutor(ILogger<HostedServiceExecutor> logger, IEnumerable<IHostedService> services)`
	`12`	`+ public HostedServiceExecutor(IEnumerable<IHostedService> services)`
`15`	`13`	`{`
`16`		`- _logger = logger;`
`17`	`14`	`_services = services;`
`18`	`15`	`}`
`19`	`16`
`20`		`- public Task StartAsync(CancellationToken token)`
	`17`	`+ public async Task StartAsync(CancellationToken token)`
`21`	`18`	`{`
`22`		`- return ExecuteAsync(service => service.StartAsync(token));`
`23`		`- }`
`24`		`-`
`25`		`- public Task StopAsync(CancellationToken token)`
`26`		`- {`
`27`		`- return ExecuteAsync(service => service.StopAsync(token), throwOnFirstFailure: false);`
	`19`	`+ foreach (var service in _services)`
	`20`	`+ {`
	`21`	`+ await service.StartAsync(token);`
	`22`	`+ }`
`28`	`23`	`}`
`29`	`24`
`30`		`- private async Task ExecuteAsync(Func<IHostedService, Task> callback, bool throwOnFirstFailure = true)`
	`25`	`+ public async Task StopAsync(CancellationToken token)`
`31`	`26`	`{`
`32`	`27`	`List<Exception>? exceptions = null;`
`33`	`28`
`34`	`29`	`foreach (var service in _services)`
`35`	`30`	`{`
`36`	`31`	`try`
`37`	`32`	`{`
`38`		`- await callback(service);`
	`33`	`+ await service.StopAsync(token);`
`39`	`34`	`}`
`40`	`35`	`catch (Exception ex)`
`41`	`36`	`{`
`42`		`- if (throwOnFirstFailure)`
`43`		`- {`
`44`		`- throw;`
`45`		`- }`
`46`		`-`
`47`		`- if (exceptions == null)`
`48`		`- {`
`49`		`- exceptions = new List<Exception>();`
`50`		`- }`
`51`		`-`
	`37`	`+ exceptions ??= [];`
`52`	`38`	`exceptions.Add(ex);`
`53`	`39`	`}`
`54`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,9 @@ public void Configure(IApplicationBuilder app)`
`23`	`23`	`{`
`24`	`24`	`_methods.ConfigureDelegate(app);`
`25`	`25`	`}`
`26`		`- catch (Exception ex)`
	`26`	`+ catch (TargetInvocationException ex)`
`27`	`27`	`{`
`28`		`- if (ex is TargetInvocationException)`
`29`		`- {`
`30`		`- ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();`
`31`		`- }`
`32`		`-`
	`28`	`+ ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();`
`33`	`29`	`throw;`
`34`	`30`	`}`
`35`	`31`	`}`
`@@ -40,13 +36,9 @@ public IServiceProvider ConfigureServices(IServiceCollection services)`
`40`	`36`	`{`
`41`	`37`	`return _methods.ConfigureServicesDelegate(services);`
`42`	`38`	`}`
`43`		`- catch (Exception ex)`
	`39`	`+ catch (TargetInvocationException ex)`
`44`	`40`	`{`
`45`		`- if (ex is TargetInvocationException)`
`46`		`- {`
`47`		`- ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();`
`48`		`- }`
`49`		`-`
	`41`	`+ ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();`
`50`	`42`	`throw;`
`51`	`43`	`}`
`52`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public static IWebHostBuilder Configure(this IWebHostBuilder hostBuilder, Action`
`46`	`46`	`{`
`47`	`47`	`services.AddSingleton<IStartup>(sp =>`
`48`	`48`	`{`
`49`		`- return new DelegateStartup(sp.GetRequiredService<IServiceProviderFactory<IServiceCollection>>(), (app => configureApp(app)));`
	`49`	`+ return new DelegateStartup(sp.GetRequiredService<IServiceProviderFactory<IServiceCollection>>(), configureApp);`
`50`	`50`	`});`
`51`	`51`	`});`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,10 +107,9 @@ async Task SetTimeoutAsync()`
`107`	`107`	`await _next(context);`
`108`	`108`	`}`
`109`	`109`	`catch (OperationCanceledException operationCanceledException)`
	`110`	`+ when (linkedCts.IsCancellationRequested && !originalToken.IsCancellationRequested)`
`110`	`111`	`{`
`111`		`- if (context.Response.HasStarted \|\|`
`112`		`- !linkedCts.Token.IsCancellationRequested \|\|`
`113`		`- originalToken.IsCancellationRequested)`
	`112`	`+ if (context.Response.HasStarted)`
`114`	`113`	`{`
`115`	`114`	`// We can't produce a response, or it wasn't our timeout that caused this.`
`116`	`115`	`throw;`
Original file line number	Diff line number	Diff line change
`@@ -218,9 +218,9 @@ public async Task LoadAsync(CancellationToken cancellationToken = default)`
`218`	`218`	`// This will throw if called directly and a failure occurs. The user is expected to handle the failures.`
`219`	`219`	`if (!_loaded)`
`220`	`220`	`{`
`221`		`- using (var timeout = new CancellationTokenSource(_ioTimeout))`
	`221`	`+ using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))`
`222`	`222`	`{`
`223`		`- var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);`
	`223`	`+ cts.CancelAfter(_ioTimeout);`
`224`	`224`	`try`
`225`	`225`	`{`
`226`	`226`	`cts.Token.ThrowIfCancellationRequested();`
`@@ -234,14 +234,10 @@ public async Task LoadAsync(CancellationToken cancellationToken = default)`
`234`	`234`	`_logger.AccessingExpiredSession(_sessionKey);`
`235`	`235`	`}`
`236`	`236`	`}`
`237`		`- catch (OperationCanceledException oex)`
	`237`	`+ catch (OperationCanceledException oex) when (!cancellationToken.IsCancellationRequested && cts.IsCancellationRequested)`
`238`	`238`	`{`
`239`		`- if (timeout.Token.IsCancellationRequested)`
`240`		`- {`
`241`		`- _logger.SessionLoadingTimeout();`
`242`		`- throw new OperationCanceledException("Timed out loading the session.", oex, timeout.Token);`
`243`		`- }`
`244`		`- throw;`
	`239`	`+ _logger.SessionLoadingTimeout();`
	`240`	`+ throw new OperationCanceledException("Timed out loading the session.", oex, cts.Token);`
`245`	`241`	`}`
`246`	`242`	`}`
`247`	`243`	`_isAvailable = true;`
`@@ -252,9 +248,9 @@ public async Task LoadAsync(CancellationToken cancellationToken = default)`
`252`	`248`	`/// <inheritdoc />`
`253`	`249`	`public async Task CommitAsync(CancellationToken cancellationToken = default)`
`254`	`250`	`{`
`255`		`- using (var timeout = new CancellationTokenSource(_ioTimeout))`
	`251`	`+ using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))`
`256`	`252`	`{`
`257`		`- var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);`
	`253`	`+ cts.CancelAfter(_ioTimeout);`
`258`	`254`	`if (_isModified)`
`259`	`255`	`{`
`260`	`256`	`if (_logger.IsEnabled(LogLevel.Information))`
`@@ -293,14 +289,10 @@ await _cache.SetAsync(`
`293`	`289`	`_isModified = false;`
`294`	`290`	`_logger.SessionStored(_sessionKey, Id, _store.Count);`
`295`	`291`	`}`
`296`		`- catch (OperationCanceledException oex)`
	`292`	`+ catch (OperationCanceledException oex) when (!cancellationToken.IsCancellationRequested && cts.IsCancellationRequested)`
`297`	`293`	`{`
`298`		`- if (timeout.Token.IsCancellationRequested)`
`299`		`- {`
`300`		`- _logger.SessionCommitTimeout();`
`301`		`- throw new OperationCanceledException("Timed out committing the session.", oex, timeout.Token);`
`302`		`- }`
`303`		`- throw;`
	`294`	`+ _logger.SessionCommitTimeout();`
	`295`	`+ throw new OperationCanceledException("Timed out committing the session.", oex, cts.Token);`
`304`	`296`	`}`
`305`	`297`	`}`
`306`	`298`	`else`
`@@ -309,14 +301,10 @@ await _cache.SetAsync(`
`309`	`301`	`{`
`310`	`302`	`await _cache.RefreshAsync(_sessionKey, cts.Token);`
`311`	`303`	`}`
`312`		`- catch (OperationCanceledException oex)`
	`304`	`+ catch (OperationCanceledException oex) when (!cancellationToken.IsCancellationRequested && cts.IsCancellationRequested)`
`313`	`305`	`{`
`314`		`- if (timeout.Token.IsCancellationRequested)`
`315`		`- {`
`316`		`- _logger.SessionRefreshTimeout();`
`317`		`- throw new OperationCanceledException("Timed out refreshing the session.", oex, timeout.Token);`
`318`		`- }`
`319`		`- throw;`
	`306`	`+ _logger.SessionRefreshTimeout();`
	`307`	`+ throw new OperationCanceledException("Timed out refreshing the session.", oex, cts.Token);`
`320`	`308`	`}`
`321`	`309`	`}`
`322`	`310`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,8 +74,8 @@ public async Task<bool> IsSpaProxyRunning(CancellationToken cancellationToken)`
`74`	`74`	`{`
`75`	`75`	`var httpClient = CreateHttpClient();`
`76`	`76`
`77`		`- using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));`
`78`		`- using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);`
	`77`	`+ using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);`
	`78`	`+ cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10));`
`79`	`79`	`try`
`80`	`80`	`{`
`81`	`81`	`var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);`
`@@ -105,8 +105,8 @@ private static HttpClient CreateHttpClient()`
`105`	`105`
`106`	`106`	`private async Task<bool> ProbeSpaDevelopmentServerUrl(HttpClient httpClient, CancellationToken cancellationToken)`
`107`	`107`	`{`
`108`		`- using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));`
`109`		`- using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken);`
	`108`	`+ using var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);`
	`109`	`+ cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10));`
`110`	`110`	`try`
`111`	`111`	`{`
`112`	`112`	`var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);`