Remove isShutdown

Author: Lukasa

Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool.swift

@@ -108,8 +108,7 @@ final class HTTPConnectionPool:
                 case closeConnectionAndCreateConnection(
                     close: Connection,
                     newConnectionID: Connection.ID,
-                    on: EventLoop,
-                    isShutdown: StateMachine.ConnectionAction.IsShutdown
+                    on: EventLoop
                 )
                 case cleanupConnections(CleanupContext, isShutdown: StateMachine.ConnectionAction.IsShutdown)
                 case migration(
@@ -204,15 +203,13 @@ final class HTTPConnectionPool:
                 self.unlocked.connection = .closeConnection(connection, isShutdown: isShutdown)
             case .closeConnectionAndCreateConnection(
                 let closeConnection,
-                let isShutdown,
                 let newConnectionID,
                 let eventLoop
             ):
                 self.unlocked.connection = .closeConnectionAndCreateConnection(
                     close: closeConnection,
                     newConnectionID: newConnectionID,
-                    on: eventLoop,
-                    isShutdown: isShutdown
+                    on: eventLoop
                 )
             case .cleanupConnections(var cleanupContext, let isShutdown):
                 self.locked.connection = .cancelBackoffTimers(cleanupContext.connectBackoff)
@@ -314,8 +311,7 @@ final class HTTPConnectionPool:
         case .closeConnectionAndCreateConnection(
             let connectionToClose,
             let newConnectionID,
-            let eventLoop,
-            let isShutdown
+            let eventLoop
         ):
             self.logger.trace(
                 "closing and creating connection",
@@ -324,19 +320,11 @@ final class HTTPConnectionPool:
                 ]
             )
 
-            // If the pool is shutdown, let's just not create this new connection.
-            if case .no = isShutdown {
-                self.createConnection(newConnectionID, on: eventLoop)
-            }
+            self.createConnection(newConnectionID, on: eventLoop)
 
             // we are not interested in the close promise...
             connectionToClose.close(promise: nil)
 
-            // This isn't really reachable.
-            if case .yes(let unclean) = isShutdown {
-                self.delegate.connectionPoolDidShutdown(self, unclean: unclean)
-            }
-
         case .cleanupConnections(let cleanupContext, let isShutdown):
             for connection in cleanupContext.close {
                 connection.close(promise: nil)

Sources/AsyncHTTPClient/ConnectionPool/State Machine/HTTPConnectionPool+HTTP1StateMachine.swift

@@ -579,7 +579,6 @@ extension HTTPConnectionPool {
                 let newConnectionID = self.connections.createNewConnection(on: connectionToClose.eventLoop)
                 connectionAction = .closeConnectionAndCreateConnection(
                     closeConnection: connectionToClose,
-                    isShutdown: .no,
                     newConnectionID: newConnectionID,
                     on: connectionToClose.eventLoop
                 )

Sources/AsyncHTTPClient/ConnectionPool/State Machine/HTTPConnectionPool+StateMachine.swift

@@ -57,7 +57,6 @@ extension HTTPConnectionPool {
             case cleanupConnections(CleanupContext, isShutdown: IsShutdown)
             case closeConnectionAndCreateConnection(
                 closeConnection: Connection,
-                isShutdown: IsShutdown,
                 newConnectionID: Connection.ID,
                 on: EventLoop
             )
@@ -441,7 +440,6 @@ extension HTTPConnectionPool.StateMachine {
         )
         case closeConnectionAndCreateConnection(
             closeConnection: HTTPConnectionPool.Connection,
-            isShutdown: HTTPConnectionPool.StateMachine.ConnectionAction.IsShutdown,
             newConnectionID: HTTPConnectionPool.Connection.ID,
             on: EventLoop
         )
@@ -472,13 +470,11 @@ extension HTTPConnectionPool.StateMachine.ConnectionAction {
             self = .closeConnection(connection, isShutdown: isShutdown)
         case .closeConnectionAndCreateConnection(
             let closeConnection,
-            let isShutdown,
             let newConnectionID,
             let eventLoop
         ):
             self = .closeConnectionAndCreateConnection(
                 closeConnection: closeConnection,
-                isShutdown: isShutdown,
                 newConnectionID: newConnectionID,
                 on: eventLoop
             )
@@ -510,28 +506,14 @@ extension HTTPConnectionPool.StateMachine.ConnectionAction {
             )
         case .closeConnectionAndCreateConnection(
             closeConnection: let connection,
-            let isShutdown,
             newConnectionID: _,
             on: _
         ):
             // This event can only come _from_ the HTTP/1 pool, migrating to HTTP/2. We do not do prewarmed HTTP/2 connections,
             // so we can ignore the request for a new connection. This is thus the same as the case below.
-            fallthrough
+            return Self.closeConnection(connection, isShutdown: .no, migrationAction: migrationAction)
         case .closeConnection(let connection, let isShutdown):
-            guard isShutdown == .no else {
-                precondition(
-                    migrationAction.closeConnections.isEmpty && migrationAction.createConnections.isEmpty,
-                    "migration actions are not supported during shutdown"
-                )
-                return .closeConnection(connection, isShutdown: isShutdown)
-            }
-            var closeConnections = migrationAction.closeConnections
-            closeConnections.append(connection)
-            return .migration(
-                createConnections: migrationAction.createConnections,
-                closeConnections: closeConnections,
-                scheduleTimeout: nil
-            )
+            return Self.closeConnection(connection, isShutdown: isShutdown, migrationAction: migrationAction)
         case .scheduleTimeoutTimerAndCreateConnection(
             timeoutID: let connectionID,
             newConnectionID: _,
@@ -548,4 +530,25 @@ extension HTTPConnectionPool.StateMachine.ConnectionAction {
             )
         }
     }
+
+    private static func closeConnection(
+        _ connection: HTTPConnectionPool.Connection,
+        isShutdown: HTTPConnectionPool.StateMachine.ConnectionAction.IsShutdown,
+        migrationAction: HTTPConnectionPool.StateMachine.ConnectionMigrationAction
+    ) -> Self {
+        guard isShutdown == .no else {
+            precondition(
+                migrationAction.closeConnections.isEmpty && migrationAction.createConnections.isEmpty,
+                "migration actions are not supported during shutdown"
+            )
+            return .closeConnection(connection, isShutdown: isShutdown)
+        }
+        var closeConnections = migrationAction.closeConnections
+        closeConnections.append(connection)
+        return .migration(
+            createConnections: migrationAction.createConnections,
+            closeConnections: closeConnections,
+            scheduleTimeout: nil
+        )
+    }
 }

Tests/AsyncHTTPClientTests/HTTPConnectionPool+HTTP1StateTests.swift

@@ -1486,11 +1486,10 @@ class HTTPConnectionPool_HTTP1StateMachineTests: XCTestCase {
 
         // Here the state machine has asked us to close the connection and create a new one. That's because we've hit the
         // max usages limit.
-        guard case .closeConnectionAndCreateConnection(let toClose, let isShutdown, _, _) = action.connection else {
+        guard case .closeConnectionAndCreateConnection(let toClose, _, _) = action.connection else {
             return XCTFail("Unexpected action: \(action.connection)")
         }
         try connections.closeConnection(toClose)
-        XCTAssertEqual(isShutdown, .no)
 
         // We won't bother doing it though, it's enough that it asked.
     }