{
if (NetEventSource.Log.IsEnabled()) Trace("Creating new HTTP/1.1 connection for pool.");
- HttpConnection connection;
- using (CancellationTokenSource cts = GetConnectTimeoutCancellationTokenSource())
+ HttpConnectionWaiter<HttpConnection> waiter = queueItem.Waiter;
+ HttpConnection? connection = null;
+ Exception? connectionException = null;
+
+ CancellationTokenSource cts = GetConnectTimeoutCancellationTokenSource();
+ waiter.ConnectionCancellationTokenSource = cts;
+ try
{
- try
- {
- connection = await CreateHttp11ConnectionAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false);
- }
- catch (OperationCanceledException oce) when (oce.CancellationToken == cts.Token)
- {
- HandleHttp11ConnectionFailure(queueItem.Waiter, CreateConnectTimeoutException(oce));
- return;
- }
- catch (Exception e)
+ connection = await CreateHttp11ConnectionAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false);
+ }
+ catch (Exception e)
+ {
+ connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ?
+ CreateConnectTimeoutException(oce) :
+ e;
+ }
+ finally
+ {
+ lock (waiter)
{
- HandleHttp11ConnectionFailure(queueItem.Waiter, e);
- return;
+ waiter.ConnectionCancellationTokenSource = null;
+ cts.Dispose();
}
}
- // Add the established connection to the pool.
- ReturnHttp11Connection(connection, isNewConnection: true, queueItem.Waiter);
+ if (connection is not null)
+ {
+ // Add the established connection to the pool.
+ ReturnHttp11Connection(connection, isNewConnection: true, queueItem.Waiter);
+ }
+ else
+ {
+ Debug.Assert(connectionException is not null);
+ HandleHttp11ConnectionFailure(waiter, connectionException);
+ }
}
private void CheckForHttp11ConnectionInjection()
_http11RequestQueue.PruneCompletedRequestsFromHeadOfQueue(this);
+ // Determine if we can and should add a new connection to the pool.
+ bool willInject = _availableHttp11Connections.Count == 0 && // No available connections
+ _http11RequestQueue.Count > _pendingHttp11ConnectionCount && // More requests queued than pending connections
+ _associatedHttp11ConnectionCount < _maxHttp11Connections && // Under the connection limit
+ _http11RequestQueue.RequestsWithoutAConnectionAttempt > 0; // There are requests we haven't issued a connection attempt for
+
if (NetEventSource.Log.IsEnabled())
{
Trace($"Available HTTP/1.1 connections: {_availableHttp11Connections.Count}, Requests in the queue: {_http11RequestQueue.Count}, " +
$"Requests without a connection attempt: {_http11RequestQueue.RequestsWithoutAConnectionAttempt}, " +
$"Pending HTTP/1.1 connections: {_pendingHttp11ConnectionCount}, Total associated HTTP/1.1 connections: {_associatedHttp11ConnectionCount}, " +
- $"Max HTTP/1.1 connection limit: {_maxHttp11Connections}.");
+ $"Max HTTP/1.1 connection limit: {_maxHttp11Connections}, " +
+ $"Will inject connection: {willInject}.");
}
- // Determine if we can and should add a new connection to the pool.
- if (_availableHttp11Connections.Count == 0 && // No available connections
- _http11RequestQueue.Count > _pendingHttp11ConnectionCount && // More requests queued than pending connections
- _associatedHttp11ConnectionCount < _maxHttp11Connections && // Under the connection limit
- _http11RequestQueue.RequestsWithoutAConnectionAttempt > 0) // There are requests we haven't issued a connection attempt for
+ if (willInject)
{
_associatedHttp11ConnectionCount++;
_pendingHttp11ConnectionCount++;
}
}
- private async ValueTask<HttpConnection> GetHttp11ConnectionAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
+ private bool TryGetPooledHttp11Connection(HttpRequestMessage request, bool async, [NotNullWhen(true)] out HttpConnection? connection, [NotNullWhen(false)] out HttpConnectionWaiter<HttpConnection>? waiter)
{
- // Look for a usable idle connection.
- TaskCompletionSourceWithCancellation<HttpConnection> waiter;
while (true)
{
- HttpConnection? connection = null;
lock (SyncObj)
{
_usedSinceLastCleanup = true;
CheckForHttp11ConnectionInjection();
- // Break out of the loop and continue processing below.
- break;
+ // There were no available idle connections. This request has been added to the request queue.
+ if (NetEventSource.Log.IsEnabled()) Trace($"No available HTTP/1.1 connections; request queued.");
+ connection = null;
+ return false;
}
}
}
if (NetEventSource.Log.IsEnabled()) connection.Trace("Found usable HTTP/1.1 connection in pool.");
- return connection;
- }
-
- // There were no available idle connections. This request has been added to the request queue.
- if (NetEventSource.Log.IsEnabled()) Trace($"No available HTTP/1.1 connections; request queued.");
-
- long startingTimestamp = Stopwatch.GetTimestamp();
- try
- {
- return await waiter.WaitWithCancellationAsync(async, cancellationToken).ConfigureAwait(false);
- }
- finally
- {
- if (HttpTelemetry.Log.IsEnabled())
- {
- HttpTelemetry.Log.Http11RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);
- }
+ waiter = null;
+ return true;
}
}
if (NetEventSource.Log.IsEnabled()) Trace("Server does not support HTTP2; disabling HTTP2 use and proceeding with HTTP/1.1 connection");
bool canUse = true;
- TaskCompletionSourceWithCancellation<Http2Connection?>? waiter = null;
+ HttpConnectionWaiter<Http2Connection?>? waiter = null;
lock (SyncObj)
{
Debug.Assert(_pendingHttp2Connection);
{
if (NetEventSource.Log.IsEnabled()) Trace("Downgrading queued HTTP2 request to HTTP/1.1");
- // We don't care if this fails; that means the request was previously canceled or handled by a different connection.
+ // We are done with the HTTP2 connection attempt, no point to cancel it.
+ Volatile.Write(ref waiter.ConnectionCancellationTokenSource, null);
+
+ // We don't care if this fails; that means the request was previously canceled or handeled by a different connection.
waiter.TrySetResult(null);
lock (SyncObj)
{
if (NetEventSource.Log.IsEnabled()) Trace("Creating new HTTP/2 connection for pool.");
- Http2Connection connection;
- using (CancellationTokenSource cts = GetConnectTimeoutCancellationTokenSource())
+ Http2Connection? connection = null;
+ Exception? connectionException = null;
+ HttpConnectionWaiter<Http2Connection?> waiter = queueItem.Waiter;
+
+ CancellationTokenSource cts = GetConnectTimeoutCancellationTokenSource();
+ waiter.ConnectionCancellationTokenSource = cts;
+ try
{
- try
+ (Stream stream, TransportContext? transportContext) = await ConnectAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false);
+
+ if (IsSecure)
{
- (Stream stream, TransportContext? transportContext) = await ConnectAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false);
+ SslStream sslStream = (SslStream)stream;
- if (IsSecure)
+ if (sslStream.NegotiatedApplicationProtocol == SslApplicationProtocol.Http2)
{
- SslStream sslStream = (SslStream)stream;
+ // The server accepted our request for HTTP2.
- if (sslStream.NegotiatedApplicationProtocol == SslApplicationProtocol.Http2)
+ if (sslStream.SslProtocol < SslProtocols.Tls12)
{
- // The server accepted our request for HTTP2.
-
- if (sslStream.SslProtocol < SslProtocols.Tls12)
- {
- stream.Dispose();
- throw new HttpRequestException(SR.Format(SR.net_ssl_http2_requires_tls12, sslStream.SslProtocol));
- }
-
- connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, cts.Token).ConfigureAwait(false);
+ stream.Dispose();
+ connectionException = new HttpRequestException(SR.Format(SR.net_ssl_http2_requires_tls12, sslStream.SslProtocol));
}
else
{
- // We established an SSL connection, but the server denied our request for HTTP2.
- await HandleHttp11Downgrade(queueItem.Request, stream, transportContext, cts.Token).ConfigureAwait(false);
- return;
+ connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, cts.Token).ConfigureAwait(false);
}
}
else
{
- connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, cts.Token).ConfigureAwait(false);
+ // We established an SSL connection, but the server denied our request for HTTP2.
+ await HandleHttp11Downgrade(queueItem.Request, stream, transportContext, cts.Token).ConfigureAwait(false);
+ return;
}
}
- catch (OperationCanceledException oce) when (oce.CancellationToken == cts.Token)
+ else
{
- HandleHttp2ConnectionFailure(queueItem.Waiter, CreateConnectTimeoutException(oce));
- return;
+ connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, cts.Token).ConfigureAwait(false);
}
- catch (Exception e)
+ }
+ catch (Exception e)
+ {
+ connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ?
+ CreateConnectTimeoutException(oce) :
+ e;
+ }
+ finally
+ {
+ lock (waiter)
{
- HandleHttp2ConnectionFailure(queueItem.Waiter, e);
- return;
+ waiter.ConnectionCancellationTokenSource = null;
+ cts.Dispose();
}
}
- // Register for shutdown notification.
- // Do this before we return the connection to the pool, because that may result in it being disposed.
- ValueTask shutdownTask = connection.WaitForShutdownAsync();
+ if (connection is not null)
+ {
+ // Register for shutdown notification.
+ // Do this before we return the connection to the pool, because that may result in it being disposed.
+ ValueTask shutdownTask = connection.WaitForShutdownAsync();
- // Add the new connection to the pool.
- ReturnHttp2Connection(connection, isNewConnection: true, queueItem.Waiter);
+ // Add the new connection to the pool.
+ ReturnHttp2Connection(connection, isNewConnection: true, queueItem.Waiter);
- // Wait for connection shutdown.
- await shutdownTask.ConfigureAwait(false);
+ // Wait for connection shutdown.
+ await shutdownTask.ConfigureAwait(false);
- InvalidateHttp2Connection(connection);
+ InvalidateHttp2Connection(connection);
+ }
+ else
+ {
+ Debug.Assert(connectionException is not null);
+ HandleHttp2ConnectionFailure(waiter, connectionException);
+ }
}
private void CheckForHttp2ConnectionInjection()
_http2RequestQueue.PruneCompletedRequestsFromHeadOfQueue(this);
// Determine if we can and should add a new connection to the pool.
- if ((_availableHttp2Connections?.Count ?? 0) == 0 && // No available connections
+ int availableHttp2ConnectionCount = _availableHttp2Connections?.Count ?? 0;
+ bool willInject = availableHttp2ConnectionCount == 0 && // No available connections
!_pendingHttp2Connection && // Only allow one pending HTTP2 connection at a time
_http2RequestQueue.Count > 0 && // There are requests left on the queue
(_associatedHttp2ConnectionCount == 0 || EnableMultipleHttp2Connections) && // We allow multiple connections, or don't have a connection currently
- _http2RequestQueue.RequestsWithoutAConnectionAttempt > 0) // There are requests we haven't issued a connection attempt for
+ _http2RequestQueue.RequestsWithoutAConnectionAttempt > 0; // There are requests we haven't issued a connection attempt for
+
+ if (NetEventSource.Log.IsEnabled())
+ {
+ Trace($"Available HTTP/2.0 connections: {availableHttp2ConnectionCount}, " +
+ $"Pending HTTP/2.0 connection: {_pendingHttp2Connection}" +
+ $"Requests in the queue: {_http2RequestQueue.Count}, " +
+ $"Requests without a connection attempt: {_http2RequestQueue.RequestsWithoutAConnectionAttempt}, " +
+ $"Total associated HTTP/2.0 connections: {_associatedHttp2ConnectionCount}, " +
+ $"Will inject connection: {willInject}.");
+ }
+
+ if (willInject)
{
_associatedHttp2ConnectionCount++;
_pendingHttp2Connection = true;
}
}
- private async ValueTask<Http2Connection?> GetHttp2ConnectionAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
+ private bool TryGetPooledHttp2Connection(HttpRequestMessage request, bool async, [NotNullWhen(true)] out Http2Connection? connection, out HttpConnectionWaiter<Http2Connection?>? waiter)
{
Debug.Assert(_kind == HttpConnectionKind.Https || _kind == HttpConnectionKind.SslProxyTunnel || _kind == HttpConnectionKind.Http || _kind == HttpConnectionKind.SocksTunnel || _kind == HttpConnectionKind.SslSocksTunnel);
// Look for a usable connection.
- TaskCompletionSourceWithCancellation<Http2Connection?> waiter;
while (true)
{
- Http2Connection connection;
lock (SyncObj)
{
_usedSinceLastCleanup = true;
if (!_http2Enabled)
{
- return null;
+ waiter = null;
+ connection = null;
+ return false;
}
int availableConnectionCount = _availableHttp2Connections?.Count ?? 0;
CheckForHttp2ConnectionInjection();
- // Break out of the loop and continue processing below.
- break;
+ // There were no available connections. This request has been added to the request queue.
+ if (NetEventSource.Log.IsEnabled()) Trace($"No available HTTP/2 connections; request queued.");
+ connection = null;
+ return false;
}
}
}
if (NetEventSource.Log.IsEnabled()) connection.Trace("Found usable HTTP/2 connection in pool.");
- return connection;
- }
-
- // There were no available connections. This request has been added to the request queue.
- if (NetEventSource.Log.IsEnabled()) Trace($"No available HTTP/2 connections; request queued.");
-
- long startingTimestamp = Stopwatch.GetTimestamp();
- try
- {
- return await waiter.WaitWithCancellationAsync(async, cancellationToken).ConfigureAwait(false);
- }
- finally
- {
- if (HttpTelemetry.Log.IsEnabled())
- {
- HttpTelemetry.Log.Http20RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);
- }
+ waiter = null;
+ return true;
}
}
int retryCount = 0;
while (true)
{
+ HttpConnectionWaiter<HttpConnection>? http11ConnectionWaiter = null;
+ HttpConnectionWaiter<Http2Connection?>? http2ConnectionWaiter = null;
try
{
HttpResponseMessage? response = null;
(request.Version.Major >= 2 || (request.VersionPolicy == HttpVersionPolicy.RequestVersionOrHigher && IsSecure)) &&
(request.VersionPolicy != HttpVersionPolicy.RequestVersionOrLower || IsSecure)) // prefer HTTP/1.1 if connection is not secured and downgrade is possible
{
- Http2Connection? connection = await GetHttp2ConnectionAsync(request, async, cancellationToken).ConfigureAwait(false);
+ if (!TryGetPooledHttp2Connection(request, async, out Http2Connection? connection, out http2ConnectionWaiter) &&
+ http2ConnectionWaiter != null)
+ {
+ connection = await http2ConnectionWaiter.WaitForConnectionAsync(async, cancellationToken).ConfigureAwait(false);
+ }
+
Debug.Assert(connection is not null || !_http2Enabled);
if (connection is not null)
{
}
// Use HTTP/1.x.
- HttpConnection connection = await GetHttp11ConnectionAsync(request, async, cancellationToken).ConfigureAwait(false);
+ if (!TryGetPooledHttp11Connection(request, async, out HttpConnection? connection, out http11ConnectionWaiter))
+ {
+ connection = await http11ConnectionWaiter.WaitForConnectionAsync(async, cancellationToken).ConfigureAwait(false);
+ }
+
connection.Acquire(); // In case we are doing Windows (i.e. connection-based) auth, we need to ensure that we hold on to this specific connection while auth is underway.
try
{
// Eat exception and try again.
}
+ finally
+ {
+ // We never cancel both attempts at the same time. When downgrade happens, it's possible that both waiters are non-null,
+ // but in that case http2ConnectionWaiter.ConnectionCancellationTokenSource shall be null.
+ Debug.Assert(http11ConnectionWaiter is null || http2ConnectionWaiter?.ConnectionCancellationTokenSource is null);
+ CancelIfNecessary(http11ConnectionWaiter, cancellationToken.IsCancellationRequested);
+ CancelIfNecessary(http2ConnectionWaiter, cancellationToken.IsCancellationRequested);
+ }
+ }
+ }
+
+ private void CancelIfNecessary<T>(HttpConnectionWaiter<T>? waiter, bool requestCancelled)
+ {
+ int timeout = GlobalHttpSettings.SocketsHttpHandler.PendingConnectionTimeoutOnRequestCompletion;
+ if (waiter?.ConnectionCancellationTokenSource is null ||
+ timeout == Timeout.Infinite ||
+ Settings._connectTimeout != Timeout.InfiniteTimeSpan && timeout > (int)Settings._connectTimeout.TotalMilliseconds) // Do not override shorter ConnectTimeout
+ {
+ return;
+ }
+
+ lock (waiter)
+ {
+ if (waiter.ConnectionCancellationTokenSource is null)
+ {
+ return;
+ }
+
+ if (NetEventSource.Log.IsEnabled())
+ {
+ Trace($"Initiating cancellation of a pending connection attempt with delay of {timeout} ms, " +
+ $"Reason: {(requestCancelled ? "Request cancelled" : "Request served by another connection")}.");
+ }
+
+ waiter.CancelledByOriginatingRequestCompletion = true;
+ if (timeout > 0)
+ {
+ // Cancel after the specified timeout. This cancellation will not fire if the connection
+ // succeeds within the delay and the CTS becomes disposed.
+ waiter.ConnectionCancellationTokenSource.CancelAfter(timeout);
+ }
+ else
+ {
+ // Cancel immediately if no timeout specified.
+ waiter.ConnectionCancellationTokenSource.Cancel();
+ }
}
}
return stream;
}
- private void HandleHttp11ConnectionFailure(TaskCompletionSourceWithCancellation<HttpConnection>? requestWaiter, Exception e)
+ private void HandleHttp11ConnectionFailure(HttpConnectionWaiter<HttpConnection>? requestWaiter, Exception e)
{
if (NetEventSource.Log.IsEnabled()) Trace($"HTTP/1.1 connection failed: {e}");
}
}
- private void HandleHttp2ConnectionFailure(TaskCompletionSourceWithCancellation<Http2Connection?> requestWaiter, Exception e)
+ private void HandleHttp2ConnectionFailure(HttpConnectionWaiter<Http2Connection?> requestWaiter, Exception e)
{
if (NetEventSource.Log.IsEnabled()) Trace($"HTTP2 connection failed: {e}");
return false;
}
- public void ReturnHttp11Connection(HttpConnection connection, bool isNewConnection, TaskCompletionSourceWithCancellation<HttpConnection>? initialRequestWaiter = null)
+ public void RecycleHttp11Connection(HttpConnection connection) => ReturnHttp11Connection(connection, false);
+
+ private void ReturnHttp11Connection(HttpConnection connection, bool isNewConnection, HttpConnectionWaiter<HttpConnection>? initialRequestWaiter = null)
{
if (NetEventSource.Log.IsEnabled()) connection.Trace($"{nameof(isNewConnection)}={isNewConnection}");
// Loop in case we get a request that has already been canceled or handled by a different connection.
while (true)
{
- TaskCompletionSourceWithCancellation<HttpConnection>? waiter = null;
+ HttpConnectionWaiter<HttpConnection>? waiter = null;
bool added = false;
lock (SyncObj)
{
}
}
- public void ReturnHttp2Connection(Http2Connection connection, bool isNewConnection, TaskCompletionSourceWithCancellation<Http2Connection?>? initialRequestWaiter = null)
+ private void ReturnHttp2Connection(Http2Connection connection, bool isNewConnection, HttpConnectionWaiter<Http2Connection?>? initialRequestWaiter = null)
{
if (NetEventSource.Log.IsEnabled()) connection.Trace($"{nameof(isNewConnection)}={isNewConnection}");
// Loop in case we get a request that has already been canceled or handled by a different connection.
while (true)
{
- TaskCompletionSourceWithCancellation<Http2Connection?>? waiter = null;
+ HttpConnectionWaiter<Http2Connection?>? waiter = null;
bool added = false;
lock (SyncObj)
{
public struct QueueItem
{
public HttpRequestMessage Request;
- public TaskCompletionSourceWithCancellation<T> Waiter;
+ public HttpConnectionWaiter<T> Waiter;
}
// This implementation mimics that of Queue<T>, but without version checks and with an extra head pointer
}
- public TaskCompletionSourceWithCancellation<T> EnqueueRequest(HttpRequestMessage request)
+ public HttpConnectionWaiter<T> EnqueueRequest(HttpRequestMessage request)
{
- var waiter = new TaskCompletionSourceWithCancellation<T>();
+ var waiter = new HttpConnectionWaiter<T>();
Enqueue(new QueueItem { Request = request, Waiter = waiter });
return waiter;
}
}
}
- public bool TryDequeueWaiter(HttpConnectionPool pool, [MaybeNullWhen(false)] out TaskCompletionSourceWithCancellation<T> waiter)
+ public bool TryDequeueWaiter(HttpConnectionPool pool, [MaybeNullWhen(false)] out HttpConnectionWaiter<T> waiter)
{
PruneCompletedRequestsFromHeadOfQueue(pool);
return false;
}
- public void TryDequeueSpecificWaiter(TaskCompletionSourceWithCancellation<T> waiter)
+ public void TryDequeueSpecificWaiter(HttpConnectionWaiter<T> waiter)
{
if (TryPeek(out QueueItem queueItem) && queueItem.Waiter == waiter)
{
public int RequestsWithoutAConnectionAttempt => _size - _attemptedConnectionsOffset;
}
+
+ private sealed class HttpConnectionWaiter<T> : TaskCompletionSourceWithCancellation<T>
+ {
+ // When a connection attempt is pending, reference the connection's CTS, so we can tear it down if the initiating request is cancelled
+ // or completes on a different connection.
+ public CancellationTokenSource? ConnectionCancellationTokenSource;
+
+ // Distinguish connection cancellation that happens because the initiating request is cancelled or completed on a different connection.
+ public bool CancelledByOriginatingRequestCompletion { get; set; }
+
+ public async ValueTask<T> WaitForConnectionAsync(bool async, CancellationToken requestCancellationToken)
+ {
+ long startingTimestamp = Stopwatch.GetTimestamp();
+ try
+ {
+ return await WaitWithCancellationAsync(async, requestCancellationToken).ConfigureAwait(false);
+ }
+ finally
+ {
+ if (HttpTelemetry.Log.IsEnabled())
+ {
+ if (typeof(T) == typeof(HttpConnection))
+ HttpTelemetry.Log.Http11RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);
+ else if (typeof(T) == typeof(Http2Connection))
+ HttpTelemetry.Log.Http20RequestLeftQueue(Stopwatch.GetElapsedTime(startingTimestamp).TotalMilliseconds);
+ }
+ }
+ }
+ }
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using System.Net.Sockets;
+using System.Net.Test.Common;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.DotNet.RemoteExecutor;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace System.Net.Http.Functional.Tests
+{
+ [Collection(nameof(DisableParallelization))] // Reduces chance of timing-related issues
+ [ConditionalClass(typeof(SocketsHttpHandler), nameof(SocketsHttpHandler.IsSupported))]
+ public class SocketsHttpHandler_Cancellation_Test_NonParallel : HttpClientHandlerTestBase
+ {
+ public SocketsHttpHandler_Cancellation_Test_NonParallel(ITestOutputHelper output) : base(output)
+ {
+ }
+
+ [OuterLoop("Incurs significant delay.")]
+ [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+ [InlineData("1.1", 10_000, 1_000, 100)]
+ [InlineData("2.0", 10_000, 1_000, 100)]
+ [InlineData("1.1", 20_000, 10_000, null)]
+ [InlineData("2.0", 20_000, 10_000, null)]
+ public static void CancelPendingRequest_DropsStalledConnectionAttempt(string versionString, int firstConnectionDelayMs, int requestTimeoutMs, int? pendingConnectionTimeoutOnRequestCompletion)
+ {
+ RemoteInvokeOptions options = new RemoteInvokeOptions();
+ if (pendingConnectionTimeoutOnRequestCompletion is not null)
+ {
+ options.StartInfo.EnvironmentVariables["DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_PENDINGCONNECTIONTIMEOUTONREQUESTCOMPLETION"] = pendingConnectionTimeoutOnRequestCompletion.ToString();
+ }
+
+ RemoteExecutor.Invoke(CancelPendingRequest_DropsStalledConnectionAttempt_Impl, versionString, firstConnectionDelayMs.ToString(), requestTimeoutMs.ToString(), options).Dispose();
+ }
+
+ private static async Task CancelPendingRequest_DropsStalledConnectionAttempt_Impl(string versionString, string firstConnectionDelayMsString, string requestTimeoutMsString)
+ {
+ var version = Version.Parse(versionString);
+ LoopbackServerFactory factory = GetFactoryForVersion(version);
+
+ const int AttemptCount = 3;
+ int firstConnectionDelayMs = int.Parse(firstConnectionDelayMsString);
+ int requestTimeoutMs = int.Parse(requestTimeoutMsString);
+ bool firstConnection = true;
+
+ using CancellationTokenSource cts0 = new CancellationTokenSource(requestTimeoutMs);
+
+ await factory.CreateClientAndServerAsync(async uri =>
+ {
+ using var handler = CreateHttpClientHandler(version);
+ GetUnderlyingSocketsHttpHandler(handler).ConnectCallback = DoConnect;
+ using var client = new HttpClient(handler) { DefaultRequestVersion = version };
+
+ await Assert.ThrowsAnyAsync<TaskCanceledException>(async () =>
+ {
+ await client.GetAsync(uri, cts0.Token);
+ });
+
+ for (int i = 0; i < AttemptCount; i++)
+ {
+ using var cts1 = new CancellationTokenSource(requestTimeoutMs);
+ using var response = await client.GetAsync(uri, cts1.Token);
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ }
+ }, async server =>
+ {
+ await server.AcceptConnectionAsync(async connection =>
+ {
+ for (int i = 0; i < AttemptCount; i++)
+ {
+ await connection.ReadRequestDataAsync();
+ await connection.SendResponseAsync();
+ connection.CompleteRequestProcessing();
+ }
+ });
+ });
+
+ async ValueTask<Stream> DoConnect(SocketsHttpConnectionContext ctx, CancellationToken cancellationToken)
+ {
+ if (firstConnection)
+ {
+ firstConnection = false;
+ await Task.Delay(100, cancellationToken); // Wait for the request to be pushed to the queue
+ cts0.Cancel(); // cancel the first request faster than RequestTimeoutMs
+ await Task.Delay(firstConnectionDelayMs, cancellationToken); // Simulate stalled connection
+ }
+ var s = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
+ await s.ConnectAsync(ctx.DnsEndPoint, cancellationToken);
+
+ return new NetworkStream(s, ownsSocket: true);
+ }
+ }
+
+ [OuterLoop("Incurs significant delay.")]
+ [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+ [InlineData(20_000)]
+ [InlineData(Timeout.Infinite)]
+ public void PendingConnectionTimeout_HighValue_PendingConnectionIsNotCancelled(int timeout)
+ {
+ RemoteExecutor.Invoke(async timoutStr =>
+ {
+ // Setup "infinite" timeout of int.MaxValue milliseconds
+ AppContext.SetData("System.Net.SocketsHttpHandler.PendingConnectionTimeoutOnRequestCompletion", int.Parse(timoutStr));
+
+ bool connected = false;
+ CancellationTokenSource cts = new CancellationTokenSource();
+
+ await new Http11LoopbackServerFactory().CreateClientAndServerAsync(async uri =>
+ {
+ using var handler = CreateHttpClientHandler(HttpVersion.Version11);
+ GetUnderlyingSocketsHttpHandler(handler).ConnectCallback = DoConnect;
+ using var client = new HttpClient(handler) { DefaultRequestVersion = HttpVersion.Version11 };
+
+ await Assert.ThrowsAnyAsync<TaskCanceledException>(() => client.GetAsync(uri, cts.Token));
+ },
+ async server => {
+ await server.AcceptConnectionAsync(_ => Task.CompletedTask).WaitAsync(30_000);
+ });
+
+ async ValueTask<Stream> DoConnect(SocketsHttpConnectionContext ctx, CancellationToken cancellationToken)
+ {
+ var s = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
+ await Task.Delay(100, cancellationToken); // Wait for the request to be pushed to the queue
+ cts.Cancel();
+
+ await Task.Delay(10_000, cancellationToken);
+ await s.ConnectAsync(ctx.DnsEndPoint, cancellationToken);
+ connected = true;
+ return new NetworkStream(s, ownsSocket: true);
+ }
+
+ Assert.True(connected);
+ }, timeout.ToString()).Dispose();
+ }
+ }
+}
projects / platform / upstream / dotnet / runtime.git / commitdiff