Do not send a keep-alive header for HTTP/1.1 (#701)

Author: Kaliumhexacyanoferrat

Engine/Internal/Protocol/ClientHandler.cs

@@ -166,7 +166,7 @@ private async ValueTask<ConnectionStatus> HandleRequest(RequestBuilder builder,
             return ConnectionStatus.Upgraded;
         }
 
-        var active = await ResponseHandler.Handle(request, response, keepAlive, dataRemaining);
+        var active = await ResponseHandler.Handle(request, response, request.ProtocolType, keepAlive, dataRemaining);
 
         return (active && keepAlive) ? ConnectionStatus.KeepAlive : ConnectionStatus.Close;
     }
@@ -181,7 +181,7 @@ private async ValueTask SendError(Exception e, ResponseStatus status)
                                                 .Content(new StringContent(message))
                                                 .Build();
 
-            await ResponseHandler.Handle(null, response, false, false);
+            await ResponseHandler.Handle(null, response, HttpProtocol.Http10, false, false);
         }
         catch
         {

Engine/Internal/Protocol/ResponseHandler.cs

@@ -48,13 +48,13 @@ internal ResponseHandler(IServer server, Socket socket, Stream outputStream, Net
 
     #region Functionality
 
-    internal async ValueTask<bool> Handle(IRequest? request, IResponse response, bool keepAlive, bool dataRemaining)
+    internal async ValueTask<bool> Handle(IRequest? request, IResponse response, HttpProtocol version, bool keepAlive, bool dataRemaining)
     {
         try
         {
             await WriteStatus(request, response);
 
-            await WriteHeader(response, keepAlive);
+            await WriteHeader(response, version, keepAlive);
 
             await Write(NL);
 
@@ -99,7 +99,7 @@ private ValueTask WriteStatus(IRequest? request, IResponse response)
         return Write("HTTP/", version, " ", NumberStringCache.Convert(response.Status.RawStatus), " ", response.Status.Phrase, NL);
     }
 
-    private async ValueTask WriteHeader(IResponse response, bool keepAlive)
+    private async ValueTask WriteHeader(IResponse response, HttpProtocol version, bool keepAlive)
     {
         if (response.Headers.TryGetValue(ServerHeader, out var server))
         {
@@ -112,7 +112,15 @@ private async ValueTask WriteHeader(IResponse response, bool keepAlive)
 
         await WriteHeaderLine("Date", DateHeader.GetValue());
 
-        await WriteHeaderLine("Connection", keepAlive ? "Keep-Alive" : "Close");
+        if (version == HttpProtocol.Http10)
+        {
+            await WriteHeaderLine("Connection", keepAlive ? "Keep-Alive" : "Close");
+        }
+        else if (!keepAlive)
+        {
+            // HTTP/1.1 connections are persistent by default so we do not need to send a Keep-Alive header
+            await WriteHeaderLine("Connection", "Close");
+        }
 
         if (response.ContentType is not null)
         {

Testing/Acceptance/Engine/BasicTests.cs

@@ -65,13 +65,13 @@ public async Task TestEmptyQuery(TestEngine engine)
     }
 
     [TestMethod]
-    public async Task TestKeepalive()
+    public async Task TestNoKeepAliveHeaderOn11()
     {
         await using var runner = await TestHost.RunAsync(Layout.Create());
 
         using var response = await runner.GetResponseAsync();
 
-        Assert.Contains("Keep-Alive", response.Headers.Connection);
+        Assert.DoesNotContain("Keep-Alive", response.Headers.Connection);
     }
 
 }

Testing/Acceptance/Engine/KeepAliveTests.cs

@@ -0,0 +1,52 @@
+using System.Net;
+using System.Net.Sockets;
+
+using GenHTTP.Api.Content;
+using GenHTTP.Api.Protocol;
+
+using GenHTTP.Modules.Functional;
+
+namespace GenHTTP.Testing.Acceptance.Engine;
+
+[TestClass]
+public class KeepAliveTests
+{
+
+    /// <summary>
+    /// This is a white box test that verifies that two subsequent requests
+    /// to the server from the same client reuse the same connection,
+    /// thus verifying that keep-alive connections are supported.
+    /// </summary>
+    [TestMethod]
+    public async Task TestKeepAlive()
+    {
+        Socket? connection = null;
+
+        var tester = Inline.Create()
+                           .Get((IRequest r) =>
+                           {
+                               var socket = r.Upgrade().Socket;
+
+                               if (connection == null)
+                               {
+                                   connection = socket;
+                               }
+                               else
+                               {
+                                   if (connection != socket)
+                                   {
+                                       throw new ProviderException(ResponseStatus.BadRequest, "Client connection did change, so this is not a keep-alive request");
+                                   }
+                               }
+                           });
+
+        await using var runner = await TestHost.RunAsync(tester, engine: TestEngine.Internal);
+
+        using var r1 = await runner.GetResponseAsync();
+        await r1.AssertStatusAsync(HttpStatusCode.NoContent);
+
+        using var r2 = await runner.GetResponseAsync();
+        await r2.AssertStatusAsync(HttpStatusCode.NoContent);
+    }
+
+}