Respect CancellationToken in HubConnection.StartAsync() (#10140)

danielloczi · halter73 · commit dbe9ab7dd5b0 · 2019-05-22T14:37:08.000-07:00
diff --git a/src/SignalR/clients/csharp/Client.Core/src/HubConnection.cs b/src/SignalR/clients/csharp/Client.Core/src/HubConnection.cs
@@ -253,7 +253,10 @@ private async Task StartAsyncInner(CancellationToken cancellationToken = default
                     throw new InvalidOperationException($"The {nameof(HubConnection)} cannot be started while {nameof(StopAsync)} is running.");
                 }
 
-                await StartAsyncCore(cancellationToken);
+                using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _state.StopCts.Token))
+                {
+                    await StartAsyncCore(cancellationToken);
+                }
 
                 _state.ChangeState(HubConnectionState.Connecting, HubConnectionState.Connected);
             }
@@ -422,7 +425,7 @@ private async Task StartAsyncCore(CancellationToken cancellationToken)
             Log.Starting(_logger);
 
             // Start the connection
-            var connection = await _connectionFactory.ConnectAsync(_protocol.TransferFormat);
+            var connection = await _connectionFactory.ConnectAsync(_protocol.TransferFormat, cancellationToken);
             var startingConnectionState = new ConnectionState(connection, this);
 
             // From here on, if an error occurs we need to shut down the connection because
@@ -1023,7 +1026,8 @@ private async Task HandshakeAsync(ConnectionState startingConnectionState, Cance
             try
             {
                 using (var handshakeCts = new CancellationTokenSource(HandshakeTimeout))
-                using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, handshakeCts.Token, _state.StopCts.Token))
+                // cancellationToken already contains _state.StopCts.Token, so we don't have to link it again
+                using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, handshakeCts.Token))
                 {
                     while (true)
                     {
@@ -1287,7 +1291,7 @@ private async Task ReconnectAsync(Exception closeException)
             var reconnectStartTime = DateTime.UtcNow;
             var retryReason = closeException;
             var nextRetryDelay = GetNextRetryDelay(previousReconnectAttempts++, TimeSpan.Zero, retryReason);
-            
+
             // We still have the connection lock from the caller, HandleConnectionClose.
             _state.AssertInConnectionLock();
 
@@ -1347,8 +1351,7 @@ private async Task ReconnectAsync(Exception closeException)
                     SafeAssert(ReferenceEquals(_state.CurrentConnectionStateUnsynchronized, null),
                         "Someone other than Reconnect set the connection state!");
 
-                    // HandshakeAsync already checks ReconnectingConnectionState.StopCts.Token.
-                    await StartAsyncCore(CancellationToken.None);
+                    await StartAsyncCore(_state.StopCts.Token);
 
                     Log.Reconnected(_logger, previousReconnectAttempts, DateTime.UtcNow - reconnectStartTime);
 
diff --git a/src/SignalR/clients/csharp/Client/test/UnitTests/TestTransport.cs b/src/SignalR/clients/csharp/Client/test/UnitTests/TestTransport.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO.Pipelines;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections;
 using Microsoft.AspNetCore.Http.Connections.Client;
@@ -29,13 +30,13 @@ public TestTransport(Func<Task> onTransportStop = null, Func<Task> onTransportSt
             Format = transferFormat;
         }
 
-        public async Task StartAsync(Uri url, TransferFormat transferFormat)
+        public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)
         {
             if ((Format & transferFormat) == 0)
             {
                 throw new InvalidOperationException($"The '{transferFormat}' transfer format is not supported by this transport.");
             }
-            
+
             var options = ClientPipeOptions.DefaultOptions;
             var pair = DuplexPipe.CreateConnectionPair(options, options);
 
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/ref/Microsoft.AspNetCore.Http.Connections.Client.netcoreapp3.0.cs b/src/SignalR/clients/csharp/Http.Connections.Client/ref/Microsoft.AspNetCore.Http.Connections.Client.netcoreapp3.0.cs
@@ -51,7 +51,7 @@ namespace Microsoft.AspNetCore.Http.Connections.Client.Internal
 {
     public partial interface ITransport : System.IO.Pipelines.IDuplexPipe
     {
-        System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat);
+        System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
         System.Threading.Tasks.Task StopAsync();
     }
     public partial interface ITransportFactory
@@ -65,7 +65,7 @@ public LongPollingTransport(System.Net.Http.HttpClient httpClient, Microsoft.Ext
         public System.IO.Pipelines.PipeReader Input { get { throw null; } }
         public System.IO.Pipelines.PipeWriter Output { get { throw null; } }
         [System.Diagnostics.DebuggerStepThroughAttribute]
-        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }
+        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task StopAsync() { throw null; }
     }
@@ -76,7 +76,7 @@ public ServerSentEventsTransport(System.Net.Http.HttpClient httpClient, Microsof
         public System.IO.Pipelines.PipeReader Input { get { throw null; } }
         public System.IO.Pipelines.PipeWriter Output { get { throw null; } }
         [System.Diagnostics.DebuggerStepThroughAttribute]
-        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }
+        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task StopAsync() { throw null; }
     }
@@ -86,7 +86,7 @@ public WebSocketsTransport(Microsoft.AspNetCore.Http.Connections.Client.HttpConn
         public System.IO.Pipelines.PipeReader Input { get { throw null; } }
         public System.IO.Pipelines.PipeWriter Output { get { throw null; } }
         [System.Diagnostics.DebuggerStepThroughAttribute]
-        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }
+        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task StopAsync() { throw null; }
     }
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/ref/Microsoft.AspNetCore.Http.Connections.Client.netstandard2.0.cs b/src/SignalR/clients/csharp/Http.Connections.Client/ref/Microsoft.AspNetCore.Http.Connections.Client.netstandard2.0.cs
@@ -51,7 +51,7 @@ namespace Microsoft.AspNetCore.Http.Connections.Client.Internal
 {
     public partial interface ITransport : System.IO.Pipelines.IDuplexPipe
     {
-        System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat);
+        System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
         System.Threading.Tasks.Task StopAsync();
     }
     public partial interface ITransportFactory
@@ -65,7 +65,7 @@ public LongPollingTransport(System.Net.Http.HttpClient httpClient, Microsoft.Ext
         public System.IO.Pipelines.PipeReader Input { get { throw null; } }
         public System.IO.Pipelines.PipeWriter Output { get { throw null; } }
         [System.Diagnostics.DebuggerStepThroughAttribute]
-        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }
+        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task StopAsync() { throw null; }
     }
@@ -76,7 +76,7 @@ public ServerSentEventsTransport(System.Net.Http.HttpClient httpClient, Microsof
         public System.IO.Pipelines.PipeReader Input { get { throw null; } }
         public System.IO.Pipelines.PipeWriter Output { get { throw null; } }
         [System.Diagnostics.DebuggerStepThroughAttribute]
-        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }
+        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task StopAsync() { throw null; }
     }
@@ -86,7 +86,7 @@ public WebSocketsTransport(Microsoft.AspNetCore.Http.Connections.Client.HttpConn
         public System.IO.Pipelines.PipeReader Input { get { throw null; } }
         public System.IO.Pipelines.PipeWriter Output { get { throw null; } }
         [System.Diagnostics.DebuggerStepThroughAttribute]
-        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }
+        public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         [System.Diagnostics.DebuggerStepThroughAttribute]
         public System.Threading.Tasks.Task StopAsync() { throw null; }
     }
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/src/HttpConnection.cs b/src/SignalR/clients/csharp/Http.Connections.Client/src/HttpConnection.cs
@@ -188,11 +188,11 @@ public async Task StartAsync(TransferFormat transferFormat, CancellationToken ca
         {
             using (_logger.BeginScope(_logScope))
             {
-                await StartAsyncCore(transferFormat).ForceAsync();
+                await StartAsyncCore(transferFormat, cancellationToken).ForceAsync();
             }
         }
 
-        private async Task StartAsyncCore(TransferFormat transferFormat)
+        private async Task StartAsyncCore(TransferFormat transferFormat, CancellationToken cancellationToken)
         {
             CheckDisposed();
 
@@ -215,7 +215,7 @@ private async Task StartAsyncCore(TransferFormat transferFormat)
 
                 Log.Starting(_logger);
 
-                await SelectAndStartTransport(transferFormat);
+                await SelectAndStartTransport(transferFormat, cancellationToken);
 
                 _started = true;
                 Log.Started(_logger);
@@ -288,7 +288,7 @@ private async Task DisposeAsyncCore()
             }
         }
 
-        private async Task SelectAndStartTransport(TransferFormat transferFormat)
+        private async Task SelectAndStartTransport(TransferFormat transferFormat, CancellationToken cancellationToken)
         {
             var uri = _httpConnectionOptions.Url;
             // Set the initial access token provider back to the original one from options
@@ -301,7 +301,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)
                 if (_httpConnectionOptions.Transports == HttpTransportType.WebSockets)
                 {
                     Log.StartingTransport(_logger, _httpConnectionOptions.Transports, uri);
-                    await StartTransport(uri, _httpConnectionOptions.Transports, transferFormat);
+                    await StartTransport(uri, _httpConnectionOptions.Transports, transferFormat, cancellationToken);
                 }
                 else
                 {
@@ -315,7 +315,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)
 
                 do
                 {
-                    negotiationResponse = await GetNegotiationResponseAsync(uri);
+                    negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken);
 
                     if (negotiationResponse.Url != null)
                     {
@@ -379,12 +379,12 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)
                             // The negotiation response gets cleared in the fallback scenario.
                             if (negotiationResponse == null)
                             {
-                                negotiationResponse = await GetNegotiationResponseAsync(uri);
+                                negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken);
                                 connectUrl = CreateConnectUrl(uri, negotiationResponse.ConnectionId);
                             }
 
                             Log.StartingTransport(_logger, transportType, connectUrl);
-                            await StartTransport(connectUrl, transportType, transferFormat);
+                            await StartTransport(connectUrl, transportType, transferFormat, cancellationToken);
                             break;
                         }
                     }
@@ -414,7 +414,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)
             }
         }
 
-        private async Task<NegotiationResponse> NegotiateAsync(Uri url, HttpClient httpClient, ILogger logger)
+        private async Task<NegotiationResponse> NegotiateAsync(Uri url, HttpClient httpClient, ILogger logger, CancellationToken cancellationToken)
         {
             try
             {
@@ -436,7 +436,7 @@ private async Task<NegotiationResponse> NegotiateAsync(Uri url, HttpClient httpC
                     // rather than buffer the entire response. This gives a small perf boost.
                     // Note that it is important to dispose of the response when doing this to
                     // avoid leaving the connection open.
-                    using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead))
+                    using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken))
                     {
                         response.EnsureSuccessStatusCode();
                         var responseBuffer = await response.Content.ReadAsByteArrayAsync();
@@ -467,15 +467,15 @@ private static Uri CreateConnectUrl(Uri url, string connectionId)
             return Utils.AppendQueryString(url, "id=" + connectionId);
         }
 
-        private async Task StartTransport(Uri connectUrl, HttpTransportType transportType, TransferFormat transferFormat)
+        private async Task StartTransport(Uri connectUrl, HttpTransportType transportType, TransferFormat transferFormat, CancellationToken cancellationToken)
         {
             // Construct the transport
             var transport = _transportFactory.CreateTransport(transportType);
 
             // Start the transport, giving it one end of the pipe
             try
             {
-                await transport.StartAsync(connectUrl, transferFormat);
+                await transport.StartAsync(connectUrl, transferFormat, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -604,9 +604,9 @@ private static bool IsWebSocketsSupported()
 #endif
         }
 
-        private async Task<NegotiationResponse> GetNegotiationResponseAsync(Uri uri)
+        private async Task<NegotiationResponse> GetNegotiationResponseAsync(Uri uri, CancellationToken cancellationToken)
         {
-            var negotiationResponse = await NegotiateAsync(uri, _httpClient, _logger);
+            var negotiationResponse = await NegotiateAsync(uri, _httpClient, _logger, cancellationToken);
             _connectionId = negotiationResponse.ConnectionId;
             _logScope.ConnectionId = _connectionId;
             return negotiationResponse;
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/ITransport.cs b/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/ITransport.cs
@@ -3,14 +3,15 @@
 
 using System;
 using System.IO.Pipelines;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections;
 
 namespace Microsoft.AspNetCore.Http.Connections.Client.Internal
 {
     public interface ITransport : IDuplexPipe
     {
-        Task StartAsync(Uri url, TransferFormat transferFormat);
+        Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default);
         Task StopAsync();
     }
 }
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/LongPollingTransport.cs b/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/LongPollingTransport.cs
@@ -40,7 +40,7 @@ public LongPollingTransport(HttpClient httpClient, ILoggerFactory loggerFactory)
             _logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger<LongPollingTransport>();
         }
 
-        public async Task StartAsync(Uri url, TransferFormat transferFormat)
+        public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)
         {
             if (transferFormat != TransferFormat.Binary && transferFormat != TransferFormat.Text)
             {
@@ -52,7 +52,7 @@ public async Task StartAsync(Uri url, TransferFormat transferFormat)
             // Make initial long polling request
             // Server uses first long polling request to finish initializing connection and it returns without data
             var request = new HttpRequestMessage(HttpMethod.Get, url);
-            using (var response = await _httpClient.SendAsync(request))
+            using (var response = await _httpClient.SendAsync(request, cancellationToken))
             {
                 response.EnsureSuccessStatusCode();
             }
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/ServerSentEventsTransport.cs b/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/ServerSentEventsTransport.cs
@@ -46,7 +46,7 @@ public ServerSentEventsTransport(HttpClient httpClient, ILoggerFactory loggerFac
             _logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger<ServerSentEventsTransport>();
         }
 
-        public async Task StartAsync(Uri url, TransferFormat transferFormat)
+        public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)
         {
             if (transferFormat != TransferFormat.Text)
             {
@@ -62,7 +62,7 @@ public async Task StartAsync(Uri url, TransferFormat transferFormat)
 
             try
             {
-                response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, CancellationToken.None);
+                response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
                 response.EnsureSuccessStatusCode();
             }
             catch
diff --git a/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/WebSocketsTransport.cs b/src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/WebSocketsTransport.cs
@@ -89,7 +89,7 @@ public WebSocketsTransport(HttpConnectionOptions httpConnectionOptions, ILoggerF
             _accessTokenProvider = accessTokenProvider;
         }
 
-        public async Task StartAsync(Uri url, TransferFormat transferFormat)
+        public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)
         {
             if (url == null)
             {
@@ -121,7 +121,7 @@ public async Task StartAsync(Uri url, TransferFormat transferFormat)
 
             try
             {
-                await _webSocket.ConnectAsync(resolvedUrl, CancellationToken.None);
+                await _webSocket.ConnectAsync(resolvedUrl, cancellationToken);
             }
             catch
             {
diff --git a/src/SignalR/server/SignalR/test/EndToEndTests.cs b/src/SignalR/server/SignalR/test/EndToEndTests.cs
@@ -568,7 +568,7 @@ public FakeTransport()
                 }
             }
 
-            public Task StartAsync(Uri url, TransferFormat transferFormat)
+            public Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)
             {
                 var options = ClientPipeOptions.DefaultOptions;
                 var pair = DuplexPipe.CreateConnectionPair(options, options);

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.IO.Pipelines;`
	`3`	`+using System.Threading;`
`3`	`4`	`using System.Threading.Tasks;`
`4`	`5`	`using Microsoft.AspNetCore.Connections;`
`5`	`6`	`using Microsoft.AspNetCore.Http.Connections.Client;`
`@@ -29,13 +30,13 @@ public TestTransport(Func<Task> onTransportStop = null, Func<Task> onTransportSt`
`29`	`30`	`Format = transferFormat;`
`30`	`31`	`}`
`31`	`32`
`32`		`- public async Task StartAsync(Uri url, TransferFormat transferFormat)`
	`33`	`+ public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)`
`33`	`34`	`{`
`34`	`35`	`if ((Format & transferFormat) == 0)`
`35`	`36`	`{`
`36`	`37`	`throw new InvalidOperationException($"The '{transferFormat}' transfer format is not supported by this transport.");`
`37`	`38`	`}`
`38`		`-`
	`39`	`+`
`39`	`40`	`var options = ClientPipeOptions.DefaultOptions;`
`40`	`41`	`var pair = DuplexPipe.CreateConnectionPair(options, options);`
`41`	`42`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ namespace Microsoft.AspNetCore.Http.Connections.Client.Internal`
`51`	`51`	`{`
`52`	`52`	`public partial interface ITransport : System.IO.Pipelines.IDuplexPipe`
`53`	`53`	`{`
`54`		`- System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat);`
	`54`	`+ System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));`
`55`	`55`	`System.Threading.Tasks.Task StopAsync();`
`56`	`56`	`}`
`57`	`57`	`public partial interface ITransportFactory`
`@@ -65,7 +65,7 @@ public LongPollingTransport(System.Net.Http.HttpClient httpClient, Microsoft.Ext`
`65`	`65`	`public System.IO.Pipelines.PipeReader Input { get { throw null; } }`
`66`	`66`	`public System.IO.Pipelines.PipeWriter Output { get { throw null; } }`
`67`	`67`	`[System.Diagnostics.DebuggerStepThroughAttribute]`
`68`		`- public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }`
	`68`	`+ public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }`
`69`	`69`	`[System.Diagnostics.DebuggerStepThroughAttribute]`
`70`	`70`	`public System.Threading.Tasks.Task StopAsync() { throw null; }`
`71`	`71`	`}`
`@@ -76,7 +76,7 @@ public ServerSentEventsTransport(System.Net.Http.HttpClient httpClient, Microsof`
`76`	`76`	`public System.IO.Pipelines.PipeReader Input { get { throw null; } }`
`77`	`77`	`public System.IO.Pipelines.PipeWriter Output { get { throw null; } }`
`78`	`78`	`[System.Diagnostics.DebuggerStepThroughAttribute]`
`79`		`- public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }`
	`79`	`+ public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }`
`80`	`80`	`[System.Diagnostics.DebuggerStepThroughAttribute]`
`81`	`81`	`public System.Threading.Tasks.Task StopAsync() { throw null; }`
`82`	`82`	`}`
`@@ -86,7 +86,7 @@ public WebSocketsTransport(Microsoft.AspNetCore.Http.Connections.Client.HttpConn`
`86`	`86`	`public System.IO.Pipelines.PipeReader Input { get { throw null; } }`
`87`	`87`	`public System.IO.Pipelines.PipeWriter Output { get { throw null; } }`
`88`	`88`	`[System.Diagnostics.DebuggerStepThroughAttribute]`
`89`		`- public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat) { throw null; }`
	`89`	`+ public System.Threading.Tasks.Task StartAsync(System.Uri url, Microsoft.AspNetCore.Connections.TransferFormat transferFormat, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }`
`90`	`90`	`[System.Diagnostics.DebuggerStepThroughAttribute]`
`91`	`91`	`public System.Threading.Tasks.Task StopAsync() { throw null; }`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -188,11 +188,11 @@ public async Task StartAsync(TransferFormat transferFormat, CancellationToken ca`
`188`	`188`	`{`
`189`	`189`	`using (_logger.BeginScope(_logScope))`
`190`	`190`	`{`
`191`		`- await StartAsyncCore(transferFormat).ForceAsync();`
	`191`	`+ await StartAsyncCore(transferFormat, cancellationToken).ForceAsync();`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`
`195`		`- private async Task StartAsyncCore(TransferFormat transferFormat)`
	`195`	`+ private async Task StartAsyncCore(TransferFormat transferFormat, CancellationToken cancellationToken)`
`196`	`196`	`{`
`197`	`197`	`CheckDisposed();`
`198`	`198`
`@@ -215,7 +215,7 @@ private async Task StartAsyncCore(TransferFormat transferFormat)`
`215`	`215`
`216`	`216`	`Log.Starting(_logger);`
`217`	`217`
`218`		`- await SelectAndStartTransport(transferFormat);`
	`218`	`+ await SelectAndStartTransport(transferFormat, cancellationToken);`
`219`	`219`
`220`	`220`	`_started = true;`
`221`	`221`	`Log.Started(_logger);`
`@@ -288,7 +288,7 @@ private async Task DisposeAsyncCore()`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`
`291`		`- private async Task SelectAndStartTransport(TransferFormat transferFormat)`
	`291`	`+ private async Task SelectAndStartTransport(TransferFormat transferFormat, CancellationToken cancellationToken)`
`292`	`292`	`{`
`293`	`293`	`var uri = _httpConnectionOptions.Url;`
`294`	`294`	`// Set the initial access token provider back to the original one from options`
`@@ -301,7 +301,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)`
`301`	`301`	`if (_httpConnectionOptions.Transports == HttpTransportType.WebSockets)`
`302`	`302`	`{`
`303`	`303`	`Log.StartingTransport(_logger, _httpConnectionOptions.Transports, uri);`
`304`		`- await StartTransport(uri, _httpConnectionOptions.Transports, transferFormat);`
	`304`	`+ await StartTransport(uri, _httpConnectionOptions.Transports, transferFormat, cancellationToken);`
`305`	`305`	`}`
`306`	`306`	`else`
`307`	`307`	`{`
`@@ -315,7 +315,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)`
`315`	`315`
`316`	`316`	`do`
`317`	`317`	`{`
`318`		`- negotiationResponse = await GetNegotiationResponseAsync(uri);`
	`318`	`+ negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken);`
`319`	`319`
`320`	`320`	`if (negotiationResponse.Url != null)`
`321`	`321`	`{`
`@@ -379,12 +379,12 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)`
`379`	`379`	`// The negotiation response gets cleared in the fallback scenario.`
`380`	`380`	`if (negotiationResponse == null)`
`381`	`381`	`{`
`382`		`- negotiationResponse = await GetNegotiationResponseAsync(uri);`
	`382`	`+ negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken);`
`383`	`383`	`connectUrl = CreateConnectUrl(uri, negotiationResponse.ConnectionId);`
`384`	`384`	`}`
`385`	`385`
`386`	`386`	`Log.StartingTransport(_logger, transportType, connectUrl);`
`387`		`- await StartTransport(connectUrl, transportType, transferFormat);`
	`387`	`+ await StartTransport(connectUrl, transportType, transferFormat, cancellationToken);`
`388`	`388`	`break;`
`389`	`389`	`}`
`390`	`390`	`}`
`@@ -414,7 +414,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat)`
`414`	`414`	`}`
`415`	`415`	`}`
`416`	`416`
`417`		`- private async Task<NegotiationResponse> NegotiateAsync(Uri url, HttpClient httpClient, ILogger logger)`
	`417`	`+ private async Task<NegotiationResponse> NegotiateAsync(Uri url, HttpClient httpClient, ILogger logger, CancellationToken cancellationToken)`
`418`	`418`	`{`
`419`	`419`	`try`
`420`	`420`	`{`
`@@ -436,7 +436,7 @@ private async Task<NegotiationResponse> NegotiateAsync(Uri url, HttpClient httpC`
`436`	`436`	`// rather than buffer the entire response. This gives a small perf boost.`
`437`	`437`	`// Note that it is important to dispose of the response when doing this to`
`438`	`438`	`// avoid leaving the connection open.`
`439`		`- using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead))`
	`439`	`+ using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken))`
`440`	`440`	`{`
`441`	`441`	`response.EnsureSuccessStatusCode();`
`442`	`442`	`var responseBuffer = await response.Content.ReadAsByteArrayAsync();`
`@@ -467,15 +467,15 @@ private static Uri CreateConnectUrl(Uri url, string connectionId)`
`467`	`467`	`return Utils.AppendQueryString(url, "id=" + connectionId);`
`468`	`468`	`}`
`469`	`469`
`470`		`- private async Task StartTransport(Uri connectUrl, HttpTransportType transportType, TransferFormat transferFormat)`
	`470`	`+ private async Task StartTransport(Uri connectUrl, HttpTransportType transportType, TransferFormat transferFormat, CancellationToken cancellationToken)`
`471`	`471`	`{`
`472`	`472`	`// Construct the transport`
`473`	`473`	`var transport = _transportFactory.CreateTransport(transportType);`
`474`	`474`
`475`	`475`	`// Start the transport, giving it one end of the pipe`
`476`	`476`	`try`
`477`	`477`	`{`
`478`		`- await transport.StartAsync(connectUrl, transferFormat);`
	`478`	`+ await transport.StartAsync(connectUrl, transferFormat, cancellationToken);`
`479`	`479`	`}`
`480`	`480`	`catch (Exception ex)`
`481`	`481`	`{`
`@@ -604,9 +604,9 @@ private static bool IsWebSocketsSupported()`
`604`	`604`	`#endif`
`605`	`605`	`}`
`606`	`606`
`607`		`- private async Task<NegotiationResponse> GetNegotiationResponseAsync(Uri uri)`
	`607`	`+ private async Task<NegotiationResponse> GetNegotiationResponseAsync(Uri uri, CancellationToken cancellationToken)`
`608`	`608`	`{`
`609`		`- var negotiationResponse = await NegotiateAsync(uri, _httpClient, _logger);`
	`609`	`+ var negotiationResponse = await NegotiateAsync(uri, _httpClient, _logger, cancellationToken);`
`610`	`610`	`_connectionId = negotiationResponse.ConnectionId;`
`611`	`611`	`_logScope.ConnectionId = _connectionId;`
`612`	`612`	`return negotiationResponse;`
Original file line number	Diff line number	Diff line change
`@@ -3,14 +3,15 @@`
`3`	`3`
`4`	`4`	`using System;`
`5`	`5`	`using System.IO.Pipelines;`
	`6`	`+using System.Threading;`
`6`	`7`	`using System.Threading.Tasks;`
`7`	`8`	`using Microsoft.AspNetCore.Connections;`
`8`	`9`
`9`	`10`	`namespace Microsoft.AspNetCore.Http.Connections.Client.Internal`
`10`	`11`	`{`
`11`	`12`	`public interface ITransport : IDuplexPipe`
`12`	`13`	`{`
`13`		`- Task StartAsync(Uri url, TransferFormat transferFormat);`
	`14`	`+ Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default);`
`14`	`15`	`Task StopAsync();`
`15`	`16`	`}`
`16`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public LongPollingTransport(HttpClient httpClient, ILoggerFactory loggerFactory)`
`40`	`40`	`_logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger<LongPollingTransport>();`
`41`	`41`	`}`
`42`	`42`
`43`		`- public async Task StartAsync(Uri url, TransferFormat transferFormat)`
	`43`	`+ public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)`
`44`	`44`	`{`
`45`	`45`	`if (transferFormat != TransferFormat.Binary && transferFormat != TransferFormat.Text)`
`46`	`46`	`{`
`@@ -52,7 +52,7 @@ public async Task StartAsync(Uri url, TransferFormat transferFormat)`
`52`	`52`	`// Make initial long polling request`
`53`	`53`	`// Server uses first long polling request to finish initializing connection and it returns without data`
`54`	`54`	`var request = new HttpRequestMessage(HttpMethod.Get, url);`
`55`		`- using (var response = await _httpClient.SendAsync(request))`
	`55`	`+ using (var response = await _httpClient.SendAsync(request, cancellationToken))`
`56`	`56`	`{`
`57`	`57`	`response.EnsureSuccessStatusCode();`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public ServerSentEventsTransport(HttpClient httpClient, ILoggerFactory loggerFac`
`46`	`46`	`_logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger<ServerSentEventsTransport>();`
`47`	`47`	`}`
`48`	`48`
`49`		`- public async Task StartAsync(Uri url, TransferFormat transferFormat)`
	`49`	`+ public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)`
`50`	`50`	`{`
`51`	`51`	`if (transferFormat != TransferFormat.Text)`
`52`	`52`	`{`
`@@ -62,7 +62,7 @@ public async Task StartAsync(Uri url, TransferFormat transferFormat)`
`62`	`62`
`63`	`63`	`try`
`64`	`64`	`{`
`65`		`- response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, CancellationToken.None);`
	`65`	`+ response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);`
`66`	`66`	`response.EnsureSuccessStatusCode();`
`67`	`67`	`}`
`68`	`68`	`catch`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public WebSocketsTransport(HttpConnectionOptions httpConnectionOptions, ILoggerF`
`89`	`89`	`_accessTokenProvider = accessTokenProvider;`
`90`	`90`	`}`
`91`	`91`
`92`		`- public async Task StartAsync(Uri url, TransferFormat transferFormat)`
	`92`	`+ public async Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)`
`93`	`93`	`{`
`94`	`94`	`if (url == null)`
`95`	`95`	`{`
`@@ -121,7 +121,7 @@ public async Task StartAsync(Uri url, TransferFormat transferFormat)`
`121`	`121`
`122`	`122`	`try`
`123`	`123`	`{`
`124`		`- await _webSocket.ConnectAsync(resolvedUrl, CancellationToken.None);`
	`124`	`+ await _webSocket.ConnectAsync(resolvedUrl, cancellationToken);`
`125`	`125`	`}`
`126`	`126`	`catch`
`127`	`127`	`{`
Original file line number	Diff line number	Diff line change
`@@ -568,7 +568,7 @@ public FakeTransport()`
`568`	`568`	`}`
`569`	`569`	`}`
`570`	`570`
`571`		`- public Task StartAsync(Uri url, TransferFormat transferFormat)`
	`571`	`+ public Task StartAsync(Uri url, TransferFormat transferFormat, CancellationToken cancellationToken = default)`
`572`	`572`	`{`
`573`	`573`	`var options = ClientPipeOptions.DefaultOptions;`
`574`	`574`	`var pair = DuplexPipe.CreateConnectionPair(options, options);`