namespace System.Net.Http
{
- internal sealed partial class HttpConnection
+ internal partial class HttpConnection
{
private sealed class ChunkedEncodingReadStream : HttpContentReadStream
{
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
private sealed class ChunkedEncodingWriteStream : HttpContentWriteStream
{
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
private sealed class ConnectionCloseReadStream : HttpContentReadStream
{
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
private sealed class ContentLengthReadStream : HttpContentReadStream
{
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
private sealed class ContentLengthWriteStream : HttpContentWriteStream
{
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
private sealed class EmptyReadStream : HttpContentReadStream
{
using System.Net.Http.Headers;
using System.Net.Security;
using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
/// <summary>Default size of the read buffer used for the connection.</summary>
private const int InitialReadBufferSize =
}
}
- public void Dispose()
+ public void Dispose() => Dispose(disposing: true);
+
+ protected void Dispose(bool disposing)
{
// Ensure we're only disposed once. Dispose could be called concurrently, for example,
// if the request and the response were running concurrently and both incurred an exception.
{
if (NetEventSource.IsEnabled) Trace("Connection closing.");
_pool.DecrementConnectionCount();
- _stream.Dispose();
+ if (disposing)
+ {
+ GC.SuppressFinalize(this);
+ _stream.Dispose();
+ }
}
}
return true;
}
- public override string ToString() => $"{nameof(HttpConnection)}({_pool.Key})"; // Description for diagnostic purposes
+ public sealed override string ToString() => $"{nameof(HttpConnection)}({_pool.Key})"; // Description for diagnostic purposes
private static void ThrowInvalidHttpResponse() => throw new HttpRequestException(SR.net_http_invalid_response);
memberName, // method name
ToString() + ": " + message); // message
}
+
+ internal sealed class HttpConnectionWithFinalizer : HttpConnection
+ {
+ public HttpConnectionWithFinalizer(HttpConnectionPool pool, Stream stream, TransportContext transportContext) : base(pool, stream, transportContext) { }
+
+ // This class is separated from HttpConnection so we only pay the price of having a finalizer
+ // when it's actually needed, e.g. when MaxConnectionsPerServer is enabled.
+ ~HttpConnectionWithFinalizer() => Dispose(disposing: false);
+ }
}
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
private sealed class HttpConnectionContent : HttpContent
{
public HttpConnectionHandler(HttpConnectionSettings settings)
{
- _connectionPools = new HttpConnectionPools(settings, settings._maxConnectionsPerServer, usingProxy: false);
+ _connectionPools = new HttpConnectionPools(settings, usingProxy: false);
}
protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
transportContext = sslStream.TransportContext;
}
- return new HttpConnection(this, stream, transportContext);
+ return _maxConnections == int.MaxValue ?
+ new HttpConnection(this, stream, transportContext) :
+ new HttpConnectionWithFinalizer(this, stream, transportContext); // finalizer needed to signal the pool when a connection is dropped
}
/// <summary>Enqueues a waiter to the waiters list.</summary>
// CONSIDER: We are passing HttpConnectionSettings here, but all we really need are the SSL settings.
// When we refactor the SSL settings to use SslAuthenticationOptions, just pass that here.
- public HttpConnectionPools(HttpConnectionSettings settings, int maxConnectionsPerServer, bool usingProxy)
+ public HttpConnectionPools(HttpConnectionSettings settings, bool usingProxy)
{
_settings = settings;
_usingProxy = usingProxy;
- _maxConnectionsPerServer = maxConnectionsPerServer;
+ _maxConnectionsPerServer = settings._maxConnectionsPerServer;
_pools = new ConcurrentDictionary<HttpConnectionKey, HttpConnectionPool>();
// Start out with the timer not running, since we have no pools.
_innerHandler = innerHandler;
_proxy = settings._proxy ?? ConstructSystemProxy();
_defaultCredentials = settings._defaultProxyCredentials;
- _connectionPools = new HttpConnectionPools(settings, settings._maxConnectionsPerServer, usingProxy: true);
+ _connectionPools = new HttpConnectionPools(settings, usingProxy: true);
}
protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
namespace System.Net.Http
{
- internal sealed partial class HttpConnection : IDisposable
+ internal partial class HttpConnection : IDisposable
{
private sealed class RawConnectionStream : HttpContentDuplexStream
{
// See the LICENSE file in the project root for more information.
using System.Linq;
+using System.Net.Test.Common;
using System.Runtime.InteropServices;
+using System.Threading;
using System.Threading.Tasks;
using Xunit;
select client.GetAsync(secure ? Configuration.Http.RemoteEchoServer : Configuration.Http.SecureRemoteEchoServer));
}
}
+
+ [OuterLoop("Relies on kicking off GC and waiting for finalizers")]
+ [Fact]
+ public async Task GetAsync_DontDisposeResponse_EventuallyUnblocksWaiters()
+ {
+ if (!UseSocketsHttpHandler)
+ {
+ // Issue #27067. Hang.
+ return;
+ }
+
+ await LoopbackServer.CreateServerAsync(async (server, uri) =>
+ {
+ using (HttpClientHandler handler = CreateHttpClientHandler())
+ using (HttpClient client = new HttpClient(handler))
+ {
+ handler.MaxConnectionsPerServer = 1;
+
+ // Let server handle two requests.
+ const string Response = "HTTP/1.1 200 OK\r\nContent-Length: 26\r\n\r\nabcdefghijklmnopqrstuvwxyz";
+ Task serverTask1 = LoopbackServer.ReadRequestAndSendResponseAsync(server, Response);
+ Task serverTask2 = LoopbackServer.ReadRequestAndSendResponseAsync(server, Response);
+
+ // Make first request and drop the response, not explicitly disposing of it.
+ void MakeAndDropRequest() => client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead); // separated out to enable GC of response
+ MakeAndDropRequest();
+
+ // A second request should eventually succeed, once the first one is cleaned up.
+ Task<HttpResponseMessage> secondResponse = client.GetAsync(uri);
+ Assert.True(SpinWait.SpinUntil(() =>
+ {
+ GC.Collect();
+ GC.WaitForPendingFinalizers();
+ return secondResponse.IsCompleted;
+ }, 30 * 1000), "Expected second response to have completed");
+
+ await new[] { serverTask1, serverTask2, secondResponse }.WhenAllOrAnyFailed();
+ }
+ });
+ }
}
}
projects / platform / upstream / dotnet / runtime.git / commitdiff