Switch over state in HTTPConnectionPool.HTTP2StateMachine.failedToCreateNewConnection (#647)

Author: dnadoba

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

@@ -404,25 +404,34 @@ extension HTTPConnectionPool{
 }
 
 mutatingfunc failedToCreateNewConnection(_ error:Error, connectionID:Connection.ID)->Action{
- // TODO: switch over state https://github.com/swift-server/async-http-client/issues/638
 self.failedConsecutiveConnectionAttempts +=1
 self.lastConnectFailure = error
 
-guardself.retryConnectionEstablishment else{
-guardlet(index, _)=self.connections.failConnection(connectionID)else{
-preconditionFailure("A connection attempt failed, that the state machine knows nothing about. Somewhere state was lost.")
+switchself.lifecycleState {
+case.running:
+guardself.retryConnectionEstablishment else{
+guardlet(index, _)=self.connections.failConnection(connectionID)else{
+preconditionFailure("A connection attempt failed, that the state machine knows nothing about. Somewhere state was lost.")
+}
+self.connections.removeConnection(at: index)
+
+return.init(
+ request:self.failAllRequests(reason: error),
+ connection:.none
+)
 }
-self.connections.removeConnection(at: index)
 
-return.init(
- request:self.failAllRequests(reason: error),
- connection:.none
-)
+leteventLoop=self.connections.backoffNextConnectionAttempt(connectionID)
+letbackoff=calculateBackoff(failedAttempt:self.failedConsecutiveConnectionAttempts)
+return.init(request:.none, connection:.scheduleBackoffTimer(connectionID, backoff: backoff, on: eventLoop))
+case.shuttingDown:
+guardlet(index, context)=self.connections.failConnection(connectionID)else{
+preconditionFailure("A connection attempt failed, that the state machine knows nothing about. Somewhere state was lost.")
+}
+returnself.nextActionForFailedConnection(at: index, on: context.eventLoop)
+case.shutDown:
+preconditionFailure("If the pool is already shutdown, all connections must have been torn down.")
 }
-
-leteventLoop=self.connections.backoffNextConnectionAttempt(connectionID)
-letbackoff=calculateBackoff(failedAttempt:self.failedConsecutiveConnectionAttempts)
-return.init(request:.none, connection:.scheduleBackoffTimer(connectionID, backoff: backoff, on: eventLoop))
 }
 
 mutatingfunc waitingForConnectivity(_ error:Error, connectionID:Connection.ID)->Action{

Tests/AsyncHTTPClientTests/HTTPConnectionPool+HTTP2StateMachineTests+XCTest.swift

@@ -27,6 +27,7 @@ extension HTTPConnectionPool_HTTP2StateMachineTests{
 return[
 ("testCreatingOfConnection", testCreatingOfConnection),
 ("testConnectionFailureBackoff", testConnectionFailureBackoff),
+("testConnectionFailureWhileShuttingDown", testConnectionFailureWhileShuttingDown),
 ("testConnectionFailureWithoutRetry", testConnectionFailureWithoutRetry),
 ("testCancelRequestWorks", testCancelRequestWorks),
 ("testExecuteOnShuttingDownPool", testExecuteOnShuttingDownPool),

Tests/AsyncHTTPClientTests/HTTPConnectionPool+HTTP2StateMachineTests.swift

@@ -194,6 +194,44 @@ class HTTPConnectionPool_HTTP2StateMachineTests: XCTestCase{
 XCTAssertEqual(state.connectionCreationBackoffDone(newConnectionID),.none)
 }
 
+func testConnectionFailureWhileShuttingDown(){
+structSomeError:Error,Equatable{}
+letelg=EmbeddedEventLoopGroup(loops:4)
+defer{XCTAssertNoThrow(try elg.syncShutdownGracefully())}
+
+varstate=HTTPConnectionPool.HTTP2StateMachine(
+ idGenerator:.init(),
+ retryConnectionEstablishment:false,
+ lifecycleState:.running
+)
+
+letmockRequest=MockHTTPRequest(eventLoop: elg.next())
+letrequest=HTTPConnectionPool.Request(mockRequest)
+
+letaction= state.executeRequest(request)
+XCTAssertEqual(.scheduleRequestTimeout(for: request, on: mockRequest.eventLoop), action.request)
+
+ // 1. connection attempt
+guard case .createConnection(let connectionID, on:let connectionEL)= action.connection else{
+returnXCTFail("Unexpected connection action: \(action.connection)")
+}
+XCTAssert(connectionEL === mockRequest.eventLoop) // XCTAssertIdentical not available on Linux
+
+ // 2. initialise shutdown
+letshutdownAction= state.shutdown()
+XCTAssertEqual(shutdownAction.connection,.cleanupConnections(.init(), isShutdown:.no))
+guard case .failRequestsAndCancelTimeouts(let requestsToFail,let requestError)= shutdownAction.request else{
+returnXCTFail("Unexpected request action: \(action.request)")
+}
+XCTAssertEqualTypeAndValue(requestError,HTTPClientError.cancelled)
+XCTAssertEqualTypeAndValue(requestsToFail,[request])
+
+ // 3. connection attempt fails
+letfailedConnectAction= state.failedToCreateNewConnection(SomeError(), connectionID: connectionID)
+XCTAssertEqual(failedConnectAction.request,.none)
+XCTAssertEqual(failedConnectAction.connection,.cleanupConnections(.init(), isShutdown:.yes(unclean:true)))
+}
+
 func testConnectionFailureWithoutRetry(){
 structSomeError:Error,Equatable{}
 letelg=EmbeddedEventLoopGroup(loops:4)