Flow Kestrel CancellationTokens to BindAsync (#31377)

halter73 · web-flow · commit 1810cfe80e24 · 2021-03-30T00:42:37.000-07:00
diff --git a/src/Servers/Kestrel/Core/src/AnyIPListenOptions.cs b/src/Servers/Kestrel/Core/src/AnyIPListenOptions.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.Kestrel.Core.Internal;
 using Microsoft.Extensions.Logging;
@@ -18,22 +19,22 @@ internal AnyIPListenOptions(int port)
         {
         }
 
-        internal override async Task BindAsync(AddressBindContext context)
+        internal override async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
         {
             Debug.Assert(IPEndPoint != null);
 
             // when address is 'http://hostname:port', 'http://*:port', or 'http://+:port'
             try
             {
-                await base.BindAsync(context).ConfigureAwait(false);
+                await base.BindAsync(context, cancellationToken).ConfigureAwait(false);
             }
             catch (Exception ex) when (!(ex is IOException))
             {
                 context.Logger.LogDebug(CoreStrings.FormatFallbackToIPv4Any(IPEndPoint.Port));
 
                 // for machines that do not support IPv6
                 EndPoint = new IPEndPoint(IPAddress.Any, IPEndPoint.Port);
-                await base.BindAsync(context).ConfigureAwait(false);
+                await base.BindAsync(context, cancellationToken).ConfigureAwait(false);
             }
         }
     }
diff --git a/src/Servers/Kestrel/Core/src/Internal/AddressBindContext.cs b/src/Servers/Kestrel/Core/src/Internal/AddressBindContext.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 
@@ -14,7 +15,7 @@ public AddressBindContext(
             ServerAddressesFeature serverAddressesFeature,
             KestrelServerOptions serverOptions,
             ILogger logger,
-            Func<ListenOptions, Task> createBinding)
+            Func<ListenOptions, CancellationToken, Task> createBinding)
         {
             ServerAddressesFeature = serverAddressesFeature;
             ServerOptions = serverOptions;
@@ -28,6 +29,6 @@ public AddressBindContext(
         public KestrelServerOptions ServerOptions { get; }
         public ILogger Logger { get; }
 
-        public Func<ListenOptions, Task> CreateBinding { get; }
+        public Func<ListenOptions, CancellationToken, Task> CreateBinding { get; }
     }
 }
diff --git a/src/Servers/Kestrel/Core/src/Internal/AddressBinder.cs b/src/Servers/Kestrel/Core/src/Internal/AddressBinder.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Linq;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Connections;
@@ -20,7 +21,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal
 {
     internal class AddressBinder
     {
-        public static async Task BindAsync(IEnumerable<ListenOptions> listenOptions, AddressBindContext context)
+        public static async Task BindAsync(IEnumerable<ListenOptions> listenOptions, AddressBindContext context, CancellationToken cancellationToken)
         {
             var strategy = CreateStrategy(
                 listenOptions.ToArray(),
@@ -32,7 +33,7 @@ public static async Task BindAsync(IEnumerable<ListenOptions> listenOptions, Add
             context.ServerOptions.OptionsInUse.Clear();
             context.Addresses.Clear();
 
-            await strategy.BindAsync(context).ConfigureAwait(false);
+            await strategy.BindAsync(context, cancellationToken).ConfigureAwait(false);
         }
 
         private static IStrategy CreateStrategy(ListenOptions[] listenOptions, string[] addresses, bool preferAddresses)
@@ -86,11 +87,11 @@ protected internal static bool TryCreateIPEndPoint(BindingAddress address, [NotN
             return true;
         }
 
-        internal static async Task BindEndpointAsync(ListenOptions endpoint, AddressBindContext context)
+        internal static async Task BindEndpointAsync(ListenOptions endpoint, AddressBindContext context, CancellationToken cancellationToken)
         {
             try
             {
-                await context.CreateBinding(endpoint).ConfigureAwait(false);
+                await context.CreateBinding(endpoint, cancellationToken).ConfigureAwait(false);
             }
             catch (AddressInUseException ex)
             {
@@ -144,24 +145,24 @@ internal static ListenOptions ParseAddress(string address, out bool https)
 
         private interface IStrategy
         {
-            Task BindAsync(AddressBindContext context);
+            Task BindAsync(AddressBindContext context, CancellationToken cancellationToken);
         }
 
         private class DefaultAddressStrategy : IStrategy
         {
-            public async Task BindAsync(AddressBindContext context)
+            public async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
             {
                 var httpDefault = ParseAddress(Constants.DefaultServerAddress, out _);
                 context.ServerOptions.ApplyEndpointDefaults(httpDefault);
-                await httpDefault.BindAsync(context).ConfigureAwait(false);
+                await httpDefault.BindAsync(context, cancellationToken).ConfigureAwait(false);
 
                 // Conditional https default, only if a cert is available
                 var httpsDefault = ParseAddress(Constants.DefaultServerHttpsAddress, out _);
                 context.ServerOptions.ApplyEndpointDefaults(httpsDefault);
 
                 if (httpsDefault.IsTls || httpsDefault.TryUseHttps())
                 {
-                    await httpsDefault.BindAsync(context).ConfigureAwait(false);
+                    await httpsDefault.BindAsync(context, cancellationToken).ConfigureAwait(false);
                     context.Logger.LogDebug(CoreStrings.BindingToDefaultAddresses,
                         Constants.DefaultServerAddress, Constants.DefaultServerHttpsAddress);
                 }
@@ -180,12 +181,12 @@ public OverrideWithAddressesStrategy(IReadOnlyCollection<string> addresses)
             {
             }
 
-            public override Task BindAsync(AddressBindContext context)
+            public override Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
             {
                 var joined = string.Join(", ", _addresses);
                 context.Logger.LogInformation(CoreStrings.OverridingWithPreferHostingUrls, nameof(IServerAddressesFeature.PreferHostingUrls), joined);
 
-                return base.BindAsync(context);
+                return base.BindAsync(context, cancellationToken);
             }
         }
 
@@ -199,12 +200,12 @@ public OverrideWithEndpointsStrategy(IReadOnlyCollection<ListenOptions> endpoint
                 _originalAddresses = originalAddresses;
             }
 
-            public override Task BindAsync(AddressBindContext context)
+            public override Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
             {
                 var joined = string.Join(", ", _originalAddresses);
                 context.Logger.LogWarning(CoreStrings.OverridingWithKestrelOptions, joined);
 
-                return base.BindAsync(context);
+                return base.BindAsync(context, cancellationToken);
             }
         }
 
@@ -217,11 +218,11 @@ public EndpointsStrategy(IReadOnlyCollection<ListenOptions> endpoints)
                 _endpoints = endpoints;
             }
 
-            public virtual async Task BindAsync(AddressBindContext context)
+            public virtual async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
             {
                 foreach (var endpoint in _endpoints)
                 {
-                    await endpoint.BindAsync(context).ConfigureAwait(false);
+                    await endpoint.BindAsync(context, cancellationToken).ConfigureAwait(false);
                 }
             }
         }
@@ -235,7 +236,7 @@ public AddressesStrategy(IReadOnlyCollection<string> addresses)
                 _addresses = addresses;
             }
 
-            public virtual async Task BindAsync(AddressBindContext context)
+            public virtual async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
             {
                 foreach (var address in _addresses)
                 {
@@ -247,7 +248,7 @@ public virtual async Task BindAsync(AddressBindContext context)
                         options.UseHttps();
                     }
 
-                    await options.BindAsync(context).ConfigureAwait(false);
+                    await options.BindAsync(context, cancellationToken).ConfigureAwait(false);
                 }
             }
         }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Infrastructure/TransportManager.cs b/src/Servers/Kestrel/Core/src/Internal/Infrastructure/TransportManager.cs
@@ -37,19 +37,19 @@ public TransportManager(
         private ConnectionManager ConnectionManager => _serviceContext.ConnectionManager;
         private IKestrelTrace Trace => _serviceContext.Log;
 
-        public async Task<EndPoint> BindAsync(EndPoint endPoint, ConnectionDelegate connectionDelegate, EndpointConfig? endpointConfig)
+        public async Task<EndPoint> BindAsync(EndPoint endPoint, ConnectionDelegate connectionDelegate, EndpointConfig? endpointConfig, CancellationToken cancellationToken)
         {
             if (_transportFactory is null)
             {
                 throw new InvalidOperationException($"Cannot bind with {nameof(ConnectionDelegate)} no {nameof(IConnectionListenerFactory)} is registered.");
             }
 
-            var transport = await _transportFactory.BindAsync(endPoint).ConfigureAwait(false);
+            var transport = await _transportFactory.BindAsync(endPoint, cancellationToken).ConfigureAwait(false);
             StartAcceptLoop(new GenericConnectionListener(transport), c => connectionDelegate(c), endpointConfig);
             return transport.EndPoint;
         }
 
-        public async Task<EndPoint> BindAsync(EndPoint endPoint, MultiplexedConnectionDelegate multiplexedConnectionDelegate, ListenOptions listenOptions)
+        public async Task<EndPoint> BindAsync(EndPoint endPoint, MultiplexedConnectionDelegate multiplexedConnectionDelegate, ListenOptions listenOptions, CancellationToken cancellationToken)
         {
             if (_multiplexedTransportFactory is null)
             {
@@ -69,7 +69,7 @@ public async Task<EndPoint> BindAsync(EndPoint endPoint, MultiplexedConnectionDe
                 features.Set(sslServerAuthenticationOptions);
             }
 
-            var transport = await _multiplexedTransportFactory.BindAsync(endPoint, features).ConfigureAwait(false);
+            var transport = await _multiplexedTransportFactory.BindAsync(endPoint, features, cancellationToken).ConfigureAwait(false);
             StartAcceptLoop(new GenericMultiplexedConnectionListener(transport), c => multiplexedConnectionDelegate(c), listenOptions.EndpointConfig);
             return transport.EndPoint;
         }
diff --git a/src/Servers/Kestrel/Core/src/Internal/KestrelServerImpl.cs b/src/Servers/Kestrel/Core/src/Internal/KestrelServerImpl.cs
@@ -160,7 +160,7 @@ public async Task StartAsync<TContext>(IHttpApplication<TContext> application, C
 
                 ServiceContext.Heartbeat?.Start();
 
-                async Task OnBind(ListenOptions options)
+                async Task OnBind(ListenOptions options, CancellationToken onBindCancellationToken)
                 {
                     // INVESTIGATE: For some reason, MsQuic needs to bind before
                     // sockets for it to successfully listen. It also seems racy.
@@ -177,7 +177,7 @@ async Task OnBind(ListenOptions options)
                         // Add the connection limit middleware
                         multiplexedConnectionDelegate = EnforceConnectionLimit(multiplexedConnectionDelegate, Options.Limits.MaxConcurrentConnections, Trace);
 
-                        options.EndPoint = await _transportManager.BindAsync(options.EndPoint, multiplexedConnectionDelegate, options).ConfigureAwait(false);
+                        options.EndPoint = await _transportManager.BindAsync(options.EndPoint, multiplexedConnectionDelegate, options, onBindCancellationToken).ConfigureAwait(false);
                     }
 
                     // Add the HTTP middleware as the terminal connection middleware
@@ -197,7 +197,7 @@ async Task OnBind(ListenOptions options)
                         // Add the connection limit middleware
                         connectionDelegate = EnforceConnectionLimit(connectionDelegate, Options.Limits.MaxConcurrentConnections, Trace);
 
-                        options.EndPoint = await _transportManager.BindAsync(options.EndPoint, connectionDelegate, options.EndpointConfig).ConfigureAwait(false);
+                        options.EndPoint = await _transportManager.BindAsync(options.EndPoint, connectionDelegate, options.EndpointConfig, onBindCancellationToken).ConfigureAwait(false);
                     }
                 }
 
@@ -275,7 +275,7 @@ private async Task BindAsync(CancellationToken cancellationToken)
 
                 Options.ConfigurationLoader?.Load();
 
-                await AddressBinder.BindAsync(Options.ListenOptions, AddressBindContext!).ConfigureAwait(false);
+                await AddressBinder.BindAsync(Options.ListenOptions, AddressBindContext!, cancellationToken).ConfigureAwait(false);
                 _configChangedRegistration = reloadToken?.RegisterChangeCallback(TriggerRebind, this);
             }
             finally
@@ -342,8 +342,7 @@ private async Task RebindAsync()
                     {
                         try
                         {
-                            // TODO: This should probably be canceled by the _stopCts too, but we don't currently support bind cancellation even in StartAsync().
-                            await listenOption.BindAsync(AddressBindContext!).ConfigureAwait(false);
+                            await listenOption.BindAsync(AddressBindContext!, _stopCts.Token).ConfigureAwait(false);
                         }
                         catch (Exception ex)
                         {
diff --git a/src/Servers/Kestrel/Core/src/ListenOptions.cs b/src/Servers/Kestrel/Core/src/ListenOptions.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Net;
 using System.Net.Sockets;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections;
 using Microsoft.AspNetCore.Connections.Experimental;
@@ -176,9 +177,9 @@ MultiplexedConnectionDelegate IMultiplexedConnectionBuilder.Build()
             return app;
         }
 
-        internal virtual async Task BindAsync(AddressBindContext context)
+        internal virtual async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
         {
-            await AddressBinder.BindEndpointAsync(this, context).ConfigureAwait(false);
+            await AddressBinder.BindEndpointAsync(this, context, cancellationToken).ConfigureAwait(false);
             context.Addresses.Add(GetDisplayName());
         }
     }
diff --git a/src/Servers/Kestrel/Core/src/LocalhostListenOptions.cs b/src/Servers/Kestrel/Core/src/LocalhostListenOptions.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.Kestrel.Core.Internal;
 using Microsoft.Extensions.Logging;
@@ -30,16 +31,16 @@ internal override string GetDisplayName()
             return $"{Scheme}://localhost:{IPEndPoint!.Port}";
         }
 
-        internal override async Task BindAsync(AddressBindContext context)
+        internal override async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)
         {
             var exceptions = new List<Exception>();
 
             try
             {
                 var v4Options = Clone(IPAddress.Loopback);
-                await AddressBinder.BindEndpointAsync(v4Options, context).ConfigureAwait(false);
+                await AddressBinder.BindEndpointAsync(v4Options, context, cancellationToken).ConfigureAwait(false);
             }
-            catch (Exception ex) when (!(ex is IOException))
+            catch (Exception ex) when (!(ex is IOException or OperationCanceledException))
             {
                 context.Logger.LogInformation(0, CoreStrings.NetworkInterfaceBindingFailed, GetDisplayName(), "IPv4 loopback", ex.Message);
                 exceptions.Add(ex);
@@ -48,9 +49,9 @@ internal override async Task BindAsync(AddressBindContext context)
             try
             {
                 var v6Options = Clone(IPAddress.IPv6Loopback);
-                await AddressBinder.BindEndpointAsync(v6Options, context).ConfigureAwait(false);
+                await AddressBinder.BindEndpointAsync(v6Options, context, cancellationToken).ConfigureAwait(false);
             }
-            catch (Exception ex) when (!(ex is IOException))
+            catch (Exception ex) when (!(ex is IOException or OperationCanceledException))
             {
                 context.Logger.LogInformation(0, CoreStrings.NetworkInterfaceBindingFailed, GetDisplayName(), "IPv6 loopback", ex.Message);
                 exceptions.Add(ex);
diff --git a/src/Servers/Kestrel/Core/test/AddressBinderTests.cs b/src/Servers/Kestrel/Core/test/AddressBinderTests.cs
diff --git a/src/Servers/Kestrel/shared/test/TestContextFactory.cs b/src/Servers/Kestrel/shared/test/TestContextFactory.cs

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using System.Diagnostics;`
`6`	`6`	`using System.IO;`
`7`	`7`	`using System.Net;`
	`8`	`+using System.Threading;`
`8`	`9`	`using System.Threading.Tasks;`
`9`	`10`	`using Microsoft.AspNetCore.Server.Kestrel.Core.Internal;`
`10`	`11`	`using Microsoft.Extensions.Logging;`
`@@ -18,22 +19,22 @@ internal AnyIPListenOptions(int port)`
`18`	`19`	`{`
`19`	`20`	`}`
`20`	`21`
`21`		`- internal override async Task BindAsync(AddressBindContext context)`
	`22`	`+ internal override async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)`
`22`	`23`	`{`
`23`	`24`	`Debug.Assert(IPEndPoint != null);`
`24`	`25`
`25`	`26`	`// when address is 'http://hostname:port', 'http://*:port', or 'http://+:port'`
`26`	`27`	`try`
`27`	`28`	`{`
`28`		`- await base.BindAsync(context).ConfigureAwait(false);`
	`29`	`+ await base.BindAsync(context, cancellationToken).ConfigureAwait(false);`
`29`	`30`	`}`
`30`	`31`	`catch (Exception ex) when (!(ex is IOException))`
`31`	`32`	`{`
`32`	`33`	`context.Logger.LogDebug(CoreStrings.FormatFallbackToIPv4Any(IPEndPoint.Port));`
`33`	`34`
`34`	`35`	`// for machines that do not support IPv6`
`35`	`36`	`EndPoint = new IPEndPoint(IPAddress.Any, IPEndPoint.Port);`
`36`		`- await base.BindAsync(context).ConfigureAwait(false);`
	`37`	`+ await base.BindAsync(context, cancellationToken).ConfigureAwait(false);`
`37`	`38`	`}`
`38`	`39`	`}`
`39`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`using System.IO;`
`8`	`8`	`using System.Linq;`
`9`	`9`	`using System.Net;`
	`10`	`+using System.Threading;`
`10`	`11`	`using System.Threading.Tasks;`
`11`	`12`	`using Microsoft.AspNetCore.Builder;`
`12`	`13`	`using Microsoft.AspNetCore.Connections;`
`@@ -20,7 +21,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal`
`20`	`21`	`{`
`21`	`22`	`internal class AddressBinder`
`22`	`23`	`{`
`23`		`- public static async Task BindAsync(IEnumerable<ListenOptions> listenOptions, AddressBindContext context)`
	`24`	`+ public static async Task BindAsync(IEnumerable<ListenOptions> listenOptions, AddressBindContext context, CancellationToken cancellationToken)`
`24`	`25`	`{`
`25`	`26`	`var strategy = CreateStrategy(`
`26`	`27`	`listenOptions.ToArray(),`
`@@ -32,7 +33,7 @@ public static async Task BindAsync(IEnumerable<ListenOptions> listenOptions, Add`
`32`	`33`	`context.ServerOptions.OptionsInUse.Clear();`
`33`	`34`	`context.Addresses.Clear();`
`34`	`35`
`35`		`- await strategy.BindAsync(context).ConfigureAwait(false);`
	`36`	`+ await strategy.BindAsync(context, cancellationToken).ConfigureAwait(false);`
`36`	`37`	`}`
`37`	`38`
`38`	`39`	`private static IStrategy CreateStrategy(ListenOptions[] listenOptions, string[] addresses, bool preferAddresses)`
`@@ -86,11 +87,11 @@ protected internal static bool TryCreateIPEndPoint(BindingAddress address, [NotN`
`86`	`87`	`return true;`
`87`	`88`	`}`
`88`	`89`
`89`		`- internal static async Task BindEndpointAsync(ListenOptions endpoint, AddressBindContext context)`
	`90`	`+ internal static async Task BindEndpointAsync(ListenOptions endpoint, AddressBindContext context, CancellationToken cancellationToken)`
`90`	`91`	`{`
`91`	`92`	`try`
`92`	`93`	`{`
`93`		`- await context.CreateBinding(endpoint).ConfigureAwait(false);`
	`94`	`+ await context.CreateBinding(endpoint, cancellationToken).ConfigureAwait(false);`
`94`	`95`	`}`
`95`	`96`	`catch (AddressInUseException ex)`
`96`	`97`	`{`
`@@ -144,24 +145,24 @@ internal static ListenOptions ParseAddress(string address, out bool https)`
`144`	`145`
`145`	`146`	`private interface IStrategy`
`146`	`147`	`{`
`147`		`- Task BindAsync(AddressBindContext context);`
	`148`	`+ Task BindAsync(AddressBindContext context, CancellationToken cancellationToken);`
`148`	`149`	`}`
`149`	`150`
`150`	`151`	`private class DefaultAddressStrategy : IStrategy`
`151`	`152`	`{`
`152`		`- public async Task BindAsync(AddressBindContext context)`
	`153`	`+ public async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)`
`153`	`154`	`{`
`154`	`155`	`var httpDefault = ParseAddress(Constants.DefaultServerAddress, out _);`
`155`	`156`	`context.ServerOptions.ApplyEndpointDefaults(httpDefault);`
`156`		`- await httpDefault.BindAsync(context).ConfigureAwait(false);`
	`157`	`+ await httpDefault.BindAsync(context, cancellationToken).ConfigureAwait(false);`
`157`	`158`
`158`	`159`	`// Conditional https default, only if a cert is available`
`159`	`160`	`var httpsDefault = ParseAddress(Constants.DefaultServerHttpsAddress, out _);`
`160`	`161`	`context.ServerOptions.ApplyEndpointDefaults(httpsDefault);`
`161`	`162`
`162`	`163`	`if (httpsDefault.IsTls \|\| httpsDefault.TryUseHttps())`
`163`	`164`	`{`
`164`		`- await httpsDefault.BindAsync(context).ConfigureAwait(false);`
	`165`	`+ await httpsDefault.BindAsync(context, cancellationToken).ConfigureAwait(false);`
`165`	`166`	`context.Logger.LogDebug(CoreStrings.BindingToDefaultAddresses,`
`166`	`167`	`Constants.DefaultServerAddress, Constants.DefaultServerHttpsAddress);`
`167`	`168`	`}`
`@@ -180,12 +181,12 @@ public OverrideWithAddressesStrategy(IReadOnlyCollection<string> addresses)`
`180`	`181`	`{`
`181`	`182`	`}`
`182`	`183`
`183`		`- public override Task BindAsync(AddressBindContext context)`
	`184`	`+ public override Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)`
`184`	`185`	`{`
`185`	`186`	`var joined = string.Join(", ", _addresses);`
`186`	`187`	`context.Logger.LogInformation(CoreStrings.OverridingWithPreferHostingUrls, nameof(IServerAddressesFeature.PreferHostingUrls), joined);`
`187`	`188`
`188`		`- return base.BindAsync(context);`
	`189`	`+ return base.BindAsync(context, cancellationToken);`
`189`	`190`	`}`
`190`	`191`	`}`
`191`	`192`
`@@ -199,12 +200,12 @@ public OverrideWithEndpointsStrategy(IReadOnlyCollection<ListenOptions> endpoint`
`199`	`200`	`_originalAddresses = originalAddresses;`
`200`	`201`	`}`
`201`	`202`
`202`		`- public override Task BindAsync(AddressBindContext context)`
	`203`	`+ public override Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)`
`203`	`204`	`{`
`204`	`205`	`var joined = string.Join(", ", _originalAddresses);`
`205`	`206`	`context.Logger.LogWarning(CoreStrings.OverridingWithKestrelOptions, joined);`
`206`	`207`
`207`		`- return base.BindAsync(context);`
	`208`	`+ return base.BindAsync(context, cancellationToken);`
`208`	`209`	`}`
`209`	`210`	`}`
`210`	`211`
`@@ -217,11 +218,11 @@ public EndpointsStrategy(IReadOnlyCollection<ListenOptions> endpoints)`
`217`	`218`	`_endpoints = endpoints;`
`218`	`219`	`}`
`219`	`220`
`220`		`- public virtual async Task BindAsync(AddressBindContext context)`
	`221`	`+ public virtual async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)`
`221`	`222`	`{`
`222`	`223`	`foreach (var endpoint in _endpoints)`
`223`	`224`	`{`
`224`		`- await endpoint.BindAsync(context).ConfigureAwait(false);`
	`225`	`+ await endpoint.BindAsync(context, cancellationToken).ConfigureAwait(false);`
`225`	`226`	`}`
`226`	`227`	`}`
`227`	`228`	`}`
`@@ -235,7 +236,7 @@ public AddressesStrategy(IReadOnlyCollection<string> addresses)`
`235`	`236`	`_addresses = addresses;`
`236`	`237`	`}`
`237`	`238`
`238`		`- public virtual async Task BindAsync(AddressBindContext context)`
	`239`	`+ public virtual async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)`
`239`	`240`	`{`
`240`	`241`	`foreach (var address in _addresses)`
`241`	`242`	`{`
`@@ -247,7 +248,7 @@ public virtual async Task BindAsync(AddressBindContext context)`
`247`	`248`	`options.UseHttps();`
`248`	`249`	`}`
`249`	`250`
`250`		`- await options.BindAsync(context).ConfigureAwait(false);`
	`251`	`+ await options.BindAsync(context, cancellationToken).ConfigureAwait(false);`
`251`	`252`	`}`
`252`	`253`	`}`
`253`	`254`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,19 +37,19 @@ public TransportManager(`
`37`	`37`	`private ConnectionManager ConnectionManager => _serviceContext.ConnectionManager;`
`38`	`38`	`private IKestrelTrace Trace => _serviceContext.Log;`
`39`	`39`
`40`		`- public async Task<EndPoint> BindAsync(EndPoint endPoint, ConnectionDelegate connectionDelegate, EndpointConfig? endpointConfig)`
	`40`	`+ public async Task<EndPoint> BindAsync(EndPoint endPoint, ConnectionDelegate connectionDelegate, EndpointConfig? endpointConfig, CancellationToken cancellationToken)`
`41`	`41`	`{`
`42`	`42`	`if (_transportFactory is null)`
`43`	`43`	`{`
`44`	`44`	`throw new InvalidOperationException($"Cannot bind with {nameof(ConnectionDelegate)} no {nameof(IConnectionListenerFactory)} is registered.");`
`45`	`45`	`}`
`46`	`46`
`47`		`- var transport = await _transportFactory.BindAsync(endPoint).ConfigureAwait(false);`
	`47`	`+ var transport = await _transportFactory.BindAsync(endPoint, cancellationToken).ConfigureAwait(false);`
`48`	`48`	`StartAcceptLoop(new GenericConnectionListener(transport), c => connectionDelegate(c), endpointConfig);`
`49`	`49`	`return transport.EndPoint;`
`50`	`50`	`}`
`51`	`51`
`52`		`- public async Task<EndPoint> BindAsync(EndPoint endPoint, MultiplexedConnectionDelegate multiplexedConnectionDelegate, ListenOptions listenOptions)`
	`52`	`+ public async Task<EndPoint> BindAsync(EndPoint endPoint, MultiplexedConnectionDelegate multiplexedConnectionDelegate, ListenOptions listenOptions, CancellationToken cancellationToken)`
`53`	`53`	`{`
`54`	`54`	`if (_multiplexedTransportFactory is null)`
`55`	`55`	`{`
`@@ -69,7 +69,7 @@ public async Task<EndPoint> BindAsync(EndPoint endPoint, MultiplexedConnectionDe`
`69`	`69`	`features.Set(sslServerAuthenticationOptions);`
`70`	`70`	`}`
`71`	`71`
`72`		`- var transport = await _multiplexedTransportFactory.BindAsync(endPoint, features).ConfigureAwait(false);`
	`72`	`+ var transport = await _multiplexedTransportFactory.BindAsync(endPoint, features, cancellationToken).ConfigureAwait(false);`
`73`	`73`	`StartAcceptLoop(new GenericMultiplexedConnectionListener(transport), c => multiplexedConnectionDelegate(c), listenOptions.EndpointConfig);`
`74`	`74`	`return transport.EndPoint;`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ public async Task StartAsync<TContext>(IHttpApplication<TContext> application, C`
`160`	`160`
`161`	`161`	`ServiceContext.Heartbeat?.Start();`
`162`	`162`
`163`		`- async Task OnBind(ListenOptions options)`
	`163`	`+ async Task OnBind(ListenOptions options, CancellationToken onBindCancellationToken)`
`164`	`164`	`{`
`165`	`165`	`// INVESTIGATE: For some reason, MsQuic needs to bind before`
`166`	`166`	`// sockets for it to successfully listen. It also seems racy.`
`@@ -177,7 +177,7 @@ async Task OnBind(ListenOptions options)`
`177`	`177`	`// Add the connection limit middleware`
`178`	`178`	`multiplexedConnectionDelegate = EnforceConnectionLimit(multiplexedConnectionDelegate, Options.Limits.MaxConcurrentConnections, Trace);`
`179`	`179`
`180`		`- options.EndPoint = await _transportManager.BindAsync(options.EndPoint, multiplexedConnectionDelegate, options).ConfigureAwait(false);`
	`180`	`+ options.EndPoint = await _transportManager.BindAsync(options.EndPoint, multiplexedConnectionDelegate, options, onBindCancellationToken).ConfigureAwait(false);`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`// Add the HTTP middleware as the terminal connection middleware`
`@@ -197,7 +197,7 @@ async Task OnBind(ListenOptions options)`
`197`	`197`	`// Add the connection limit middleware`
`198`	`198`	`connectionDelegate = EnforceConnectionLimit(connectionDelegate, Options.Limits.MaxConcurrentConnections, Trace);`
`199`	`199`
`200`		`- options.EndPoint = await _transportManager.BindAsync(options.EndPoint, connectionDelegate, options.EndpointConfig).ConfigureAwait(false);`
	`200`	`+ options.EndPoint = await _transportManager.BindAsync(options.EndPoint, connectionDelegate, options.EndpointConfig, onBindCancellationToken).ConfigureAwait(false);`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`
`@@ -275,7 +275,7 @@ private async Task BindAsync(CancellationToken cancellationToken)`
`275`	`275`
`276`	`276`	`Options.ConfigurationLoader?.Load();`
`277`	`277`
`278`		`- await AddressBinder.BindAsync(Options.ListenOptions, AddressBindContext!).ConfigureAwait(false);`
	`278`	`+ await AddressBinder.BindAsync(Options.ListenOptions, AddressBindContext!, cancellationToken).ConfigureAwait(false);`
`279`	`279`	`_configChangedRegistration = reloadToken?.RegisterChangeCallback(TriggerRebind, this);`
`280`	`280`	`}`
`281`	`281`	`finally`
`@@ -342,8 +342,7 @@ private async Task RebindAsync()`
`342`	`342`	`{`
`343`	`343`	`try`
`344`	`344`	`{`
`345`		`- // TODO: This should probably be canceled by the _stopCts too, but we don't currently support bind cancellation even in StartAsync().`
`346`		`- await listenOption.BindAsync(AddressBindContext!).ConfigureAwait(false);`
	`345`	`+ await listenOption.BindAsync(AddressBindContext!, _stopCts.Token).ConfigureAwait(false);`
`347`	`346`	`}`
`348`	`347`	`catch (Exception ex)`
`349`	`348`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using System.Net;`
`7`	`7`	`using System.Net.Sockets;`
	`8`	`+using System.Threading;`
`8`	`9`	`using System.Threading.Tasks;`
`9`	`10`	`using Microsoft.AspNetCore.Connections;`
`10`	`11`	`using Microsoft.AspNetCore.Connections.Experimental;`
`@@ -176,9 +177,9 @@ MultiplexedConnectionDelegate IMultiplexedConnectionBuilder.Build()`
`176`	`177`	`return app;`
`177`	`178`	`}`
`178`	`179`
`179`		`- internal virtual async Task BindAsync(AddressBindContext context)`
	`180`	`+ internal virtual async Task BindAsync(AddressBindContext context, CancellationToken cancellationToken)`
`180`	`181`	`{`
`181`		`- await AddressBinder.BindEndpointAsync(this, context).ConfigureAwait(false);`
	`182`	`+ await AddressBinder.BindEndpointAsync(this, context, cancellationToken).ConfigureAwait(false);`
`182`	`183`	`context.Addresses.Add(GetDisplayName());`
`183`	`184`	`}`
`184`	`185`	`}`