Merge in 'release/7.0-rc1' changes

Author: dotnet-bot

src/Servers/Kestrel/Transport.Quic/test/QuicConnectionContextTests.cs

@@ -421,6 +421,8 @@ public async Task StreamPool_StreamAbortedOnClient_NotPooled()
     public async Task StreamPool_StreamAbortedOnClientAndServer_NotPooled()
     {
         // Arrange
+        using var httpEventSource = new HttpEventSourceListener(LoggerFactory);
+
         await using var connectionListener = await QuicTestHelpers.CreateConnectionListenerFactory(LoggerFactory);
 
         var options = QuicTestHelpers.CreateClientConnectionOptions(connectionListener.EndPoint);

src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketConnection.cs

@@ -33,7 +33,7 @@ internal sealed partial class SocketConnection : TransportConnection
 
     internal SocketConnection(Socket socket,
                               MemoryPool<byte> memoryPool,
-                              PipeScheduler transportScheduler,
+                              PipeScheduler socketScheduler,
                               ILogger logger,
                               SocketSenderPool socketSenderPool,
                               PipeOptions inputOptions,
@@ -55,12 +55,7 @@ internal SocketConnection(Socket socket,
 
         ConnectionClosed = _connectionClosedTokenSource.Token;
 
-        // On *nix platforms, Sockets already dispatches to the ThreadPool.
-        // Yes, the IOQueues are still used for the PipeSchedulers. This is intentional.
-        // https://github.com/aspnet/KestrelHttpServer/issues/2573
-        var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline;
-
-        _receiver = new SocketReceiver(awaiterScheduler);
+        _receiver = new SocketReceiver(socketScheduler);
 
         var pair = DuplexPipe.CreateConnectionPair(inputOptions, outputOptions);
 

src/Servers/Kestrel/Transport.Sockets/src/SocketConnectionContextFactory.cs

@@ -56,15 +56,13 @@ public SocketConnectionContextFactory(SocketConnectionFactoryOptions options, IL
             {
                 var memoryPool = _options.MemoryPoolFactory();
                 var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : new IOQueue();
-                // https://github.com/aspnet/KestrelHttpServer/issues/2573
-                var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline;
 
                 _settings[i] = new QueueSettings()
                 {
                     Scheduler = transportScheduler,
                     InputOptions = new PipeOptions(memoryPool, applicationScheduler, transportScheduler, maxReadBufferSize, maxReadBufferSize / 2, useSynchronizationContext: false),
                     OutputOptions = new PipeOptions(memoryPool, transportScheduler, applicationScheduler, maxWriteBufferSize, maxWriteBufferSize / 2, useSynchronizationContext: false),
-                    SocketSenderPool = new SocketSenderPool(awaiterScheduler),
+                    SocketSenderPool = new SocketSenderPool(transportScheduler),
                     MemoryPool = memoryPool,
                 };
             }
@@ -73,16 +71,14 @@ public SocketConnectionContextFactory(SocketConnectionFactoryOptions options, IL
         {
             var memoryPool = _options.MemoryPoolFactory();
             var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool;
-            // https://github.com/aspnet/KestrelHttpServer/issues/2573
-            var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline;
             _settings = new QueueSettings[]
             {
                 new QueueSettings()
                 {
                     Scheduler = transportScheduler,
                     InputOptions = new PipeOptions(memoryPool, applicationScheduler, transportScheduler, maxReadBufferSize, maxReadBufferSize / 2, useSynchronizationContext: false),
                     OutputOptions = new PipeOptions(memoryPool, transportScheduler, applicationScheduler, maxWriteBufferSize, maxWriteBufferSize / 2, useSynchronizationContext: false),
-                    SocketSenderPool = new SocketSenderPool(awaiterScheduler),
+                    SocketSenderPool = new SocketSenderPool(PipeScheduler.Inline),
                     MemoryPool = memoryPool,
                 }
             };
@@ -101,7 +97,7 @@ public ConnectionContext Create(Socket socket)
 
         var connection = new SocketConnection(socket,
             setting.MemoryPool,
-            setting.Scheduler,
+            PipeScheduler.Inline,
             _logger,
             setting.SocketSenderPool,
             setting.InputOptions,

src/Servers/Kestrel/shared/test/ServerRetryHelper.cs

@@ -1,33 +1,37 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Net;
+using System.Net.Sockets;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Testing;
 
 public static class ServerRetryHelper
 {
+    private const int RetryCount = 10;
+
     /// <summary>
     /// Retry a func. Useful when a test needs an explicit port and you want to avoid port conflicts.
     /// </summary>
     public static async Task BindPortsWithRetry(Func<int, Task> retryFunc, ILogger logger)
     {
+        var ports = GetFreePorts(RetryCount);
+
         var retryCount = 0;
         while (true)
         {
-            // Approx dynamic port range on Windows and Linux.
-            var randomPort = Random.Shared.Next(35000, 60000);
 
             try
             {
-                await retryFunc(randomPort);
+                await retryFunc(ports[retryCount]);
                 break;
             }
             catch (Exception ex)
             {
                 retryCount++;
 
-                if (retryCount >= 5)
+                if (retryCount >= RetryCount)
                 {
                     throw;
                 }
@@ -38,4 +42,35 @@ public static async Task BindPortsWithRetry(Func<int, Task> retryFunc, ILogger l
             }
         }
     }
+
+    private static int[] GetFreePorts(int count)
+    {
+        var sockets = new List<Socket>();
+
+        for (var i = 0; i < count; i++)
+        {
+            // Find a port that's free by binding port 0.
+            // Note that this port should be free when the test runs, but:
+            // - Something else could steal it before the test uses it.
+            // - UDP port with the same number could be in use.
+            // For that reason, some retries should be available.
+            var ipEndPoint = new IPEndPoint(IPAddress.Loopback, 0);
+            var listenSocket = new Socket(ipEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+
+            listenSocket.Bind(ipEndPoint);
+
+            sockets.Add(listenSocket);
+        }
+
+        // Ports are calculated upfront. Rebinding with port 0 could result the same port
+        // being returned for each retry.
+        var ports = sockets.Select(s => (IPEndPoint)s.LocalEndPoint).Select(ep => ep.Port).ToArray();
+
+        foreach (var socket in sockets)
+        {
+            socket.Dispose();
+        }
+
+        return ports;
+    }
 }

src/Servers/Kestrel/test/Interop.FunctionalTests/Http3/Http3RequestTests.cs

@@ -228,6 +228,8 @@ public async Task GET_ServerStreaming_ClientReadsPartialResponse(HttpProtocols p
     public async Task POST_ClientSendsOnlyHeaders_RequestReceivedOnServer(HttpProtocols protocol)
     {
         // Arrange
+        using var httpEventSource = new HttpEventSourceListener(LoggerFactory);
+
         var builder = CreateHostBuilder(context =>
         {
             return Task.CompletedTask;