Rename succeedRequest to receiveResponseEnd (#877)

fabianfett · web-flow · commit 4b9997567723 · 2026-01-08T11:36:36.000Z
diff --git a/Sources/AsyncHTTPClient/AsyncAwait/Transaction+StateMachine.swift b/Sources/AsyncHTTPClient/AsyncAwait/Transaction+StateMachine.swift
@@ -468,7 +468,7 @@ extension Transaction {
             case none
         }
 
-        mutating func succeedRequest(_ newChunks: CircularBuffer<ByteBuffer>?) -> ReceiveResponseEndAction {
+        mutating func receiveResponseEnd(_ newChunks: CircularBuffer<ByteBuffer>?) -> ReceiveResponseEndAction {
             switch self.state {
             case .initialized,
                 .queued,
@@ -479,8 +479,14 @@ extension Transaction {
                 )
 
             case .executing(let context, let requestState, .streamingBody(let source)):
-                self.state = .executing(context, requestState, .finished)
+                switch requestState {
+                case .finished:
+                    self.state = .finished(error: nil)
+                case .paused, .producing, .requestHeadSent:
+                    self.state = .executing(context, requestState, .finished)
+                }
                 return .finishResponseStream(source, finalBody: newChunks)
+
             case .finished:
                 // the request failed or was cancelled before, we can ignore all events
                 return .none
diff --git a/Sources/AsyncHTTPClient/AsyncAwait/Transaction.swift b/Sources/AsyncHTTPClient/AsyncAwait/Transaction.swift
@@ -286,11 +286,11 @@ extension Transaction: HTTPExecutableRequest {
         }
     }
 
-    func succeedRequest(_ buffer: CircularBuffer<ByteBuffer>?) {
-        let succeedAction = self.state.withLockedValue { state in
-            state.succeedRequest(buffer)
+    func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {
+        let receiveResponseEndAction = self.state.withLockedValue { state in
+            state.receiveResponseEnd(buffer)
         }
-        switch succeedAction {
+        switch receiveResponseEndAction {
         case .finishResponseStream(let source, let finalResponse):
             if let finalResponse = finalResponse {
                 _ = source.yield(contentsOf: finalResponse)
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift
@@ -319,7 +319,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
             switch finalAction {
             case .close:
                 context.close(promise: nil)
-                oldRequest.succeedRequest(buffer)
+                oldRequest.receiveResponseEnd(buffer, trailers: nil)
             case .sendRequestEnd(let writePromise, let shouldClose):
                 let writePromise = writePromise ?? context.eventLoop.makePromise(of: Void.self)
                 // We need to defer succeeding the old request to avoid ordering issues
@@ -336,7 +336,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
                             self.onConnectionIdle()
                         }
 
-                        oldRequest.succeedRequest(buffer)
+                        oldRequest.receiveResponseEnd(buffer, trailers: nil)
                     case .failure(let error):
                         context.close(promise: nil)
                         oldRequest.fail(error)
@@ -346,7 +346,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
                 context.writeAndFlush(self.wrapOutboundOut(.end(nil)), promise: writePromise)
             case .informConnectionIsIdle:
                 self.onConnectionIdle()
-                oldRequest.succeedRequest(buffer)
+                oldRequest.receiveResponseEnd(buffer, trailers: nil)
             }
 
         case .failRequest(let error, let finalAction):
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift
@@ -250,7 +250,7 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
         case .succeedRequest(let finalAction, let finalParts):
             // We can force unwrap the request here, as we have just validated in the state machine,
             // that the request object is still present.
-            self.request!.succeedRequest(finalParts)
+            self.request!.receiveResponseEnd(finalParts, trailers: nil)
             self.request = nil
             self.runTimeoutAction(.clearIdleReadTimeoutTimer, context: context)
             self.runTimeoutAction(.clearIdleWriteTimeoutTimer, context: context)
diff --git a/Sources/AsyncHTTPClient/ConnectionPool/HTTPExecutableRequest.swift b/Sources/AsyncHTTPClient/ConnectionPool/HTTPExecutableRequest.swift
@@ -260,10 +260,12 @@ protocol HTTPExecutableRequest: AnyObject, Sendable {
     /// to ask for more data.
     func receiveResponseBodyParts(_ buffer: CircularBuffer<ByteBuffer>)
 
-    /// Succeeds the executing request. The executor will not call any further methods on the request after this method.
+    /// Finishes the server response.
     ///
-    /// - Parameter buffer: The remaining response body parts, that were received before the request end
-    func succeedRequest(_ buffer: CircularBuffer<ByteBuffer>?)
+    /// - Parameters:
+    ///   - buffer: The remaining response body parts, that were received before the response end
+    ///   - trailers: The response trailers if any where received. Nil means no trailers were received.
+    func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?)
 
     /// Fails the executing request, with an error.
     func fail(_ error: Error)
diff --git a/Sources/AsyncHTTPClient/RequestBag+StateMachine.swift b/Sources/AsyncHTTPClient/RequestBag+StateMachine.swift
@@ -401,7 +401,7 @@ extension RequestBag.StateMachine {
         case none
     }
 
-    mutating func succeedRequest(_ newChunks: CircularBuffer<ByteBuffer>?) -> ReceiveResponseEndAction {
+    mutating func receiveResponseEnd(_ newChunks: CircularBuffer<ByteBuffer>?) -> ReceiveResponseEndAction {
         switch self.state {
         case .initialized, .queued, .deadlineExceededWhileQueued:
             preconditionFailure("How can we receive a response body part, if the request hasn't started yet.")
diff --git a/Sources/AsyncHTTPClient/RequestBag.swift b/Sources/AsyncHTTPClient/RequestBag.swift
@@ -306,8 +306,8 @@ final class RequestBag<Delegate: HTTPClientResponseDelegate & Sendable>: Sendabl
         }
     }
 
-    private func succeedRequest0(_ buffer: CircularBuffer<ByteBuffer>?) {
-        let action = self.loopBoundState.value.state.succeedRequest(buffer)
+    private func receiveResponseEnd0(_ buffer: CircularBuffer<ByteBuffer>?) {
+        let action = self.loopBoundState.value.state.receiveResponseEnd(buffer)
 
         switch action {
         case .none:
@@ -538,12 +538,12 @@ extension RequestBag: HTTPExecutableRequest {
         }
     }
 
-    func succeedRequest(_ buffer: CircularBuffer<ByteBuffer>?) {
+    func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {
         if self.task.eventLoop.inEventLoop {
-            self.succeedRequest0(buffer)
+            self.receiveResponseEnd0(buffer)
         } else {
             self.task.eventLoop.execute {
-                self.succeedRequest0(buffer)
+                self.receiveResponseEnd0(buffer)
             }
         }
     }
diff --git a/Tests/AsyncHTTPClientTests/HTTPConnectionPool+RequestQueueTests.swift b/Tests/AsyncHTTPClientTests/HTTPConnectionPool+RequestQueueTests.swift
@@ -134,7 +134,7 @@ final private class MockScheduledRequest: HTTPSchedulableRequest {
         preconditionFailure("Unimplemented")
     }
 
-    func succeedRequest(_: CircularBuffer<ByteBuffer>?) {
+    func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {
         preconditionFailure("Unimplemented")
     }
 }
diff --git a/Tests/AsyncHTTPClientTests/Mocks/MockConnectionPool.swift b/Tests/AsyncHTTPClientTests/Mocks/MockConnectionPool.swift
@@ -757,7 +757,7 @@ final class MockHTTPScheduableRequest: HTTPSchedulableRequest {
         preconditionFailure("Unimplemented")
     }
 
-    func succeedRequest(_: CircularBuffer<ByteBuffer>?) {
+    func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {
         preconditionFailure("Unimplemented")
     }
 }
diff --git a/Tests/AsyncHTTPClientTests/Mocks/MockHTTPExecutableRequest.swift b/Tests/AsyncHTTPClientTests/Mocks/MockHTTPExecutableRequest.swift
@@ -157,7 +157,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {
         receiveResponseBodyPartsCallback(buffer)
     }
 
-    func succeedRequest(_ buffer: CircularBuffer<NIOCore.ByteBuffer>?) {
+    func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {
         self.events.append(.succeedRequest(buffer))
         guard let succeedRequestCallback = succeedRequestCallback else {
             return self.calledUnimplementedMethod(#function)
diff --git a/Tests/AsyncHTTPClientTests/RequestBagTests.swift b/Tests/AsyncHTTPClientTests/RequestBagTests.swift
@@ -171,7 +171,7 @@ final class RequestBagTests: XCTestCase {
         }
 
         XCTAssertEqual(delegate.hitDidReceiveResponse, 0)
-        bag.succeedRequest(nil)
+        bag.receiveResponseEnd(nil, trailers: nil)
         XCTAssertEqual(delegate.hitDidReceiveResponse, 1)
 
         XCTAssertNoThrow(try bag.task.futureResult.wait(), "The request has succeeded")
@@ -568,7 +568,7 @@ final class RequestBagTests: XCTestCase {
 
         bag.receiveResponseHead(.init(version: .http1_1, status: .ok))
 
-        bag.succeedRequest([ByteBuffer([1])])
+        bag.receiveResponseEnd([ByteBuffer([1])], trailers: nil)
 
         XCTAssertThrowsError(try delegate.didFinishPromise.futureResult.wait()) { error in
             XCTAssertEqualTypeAndValue(error, MyError())
@@ -640,7 +640,7 @@ final class RequestBagTests: XCTestCase {
         // receive a 301 response immediately.
         bag.receiveResponseHead(.init(version: .http1_1, status: .movedPermanently))
         XCTAssertNoThrow(try XCTUnwrap(delegate.backpressurePromise).succeed(()))
-        bag.succeedRequest(.init())
+        bag.receiveResponseEnd([], trailers: nil)
 
         // if we now write our second part of the response this should fail the backpressure promise
         writeSecondPartPromise.succeed(())
@@ -695,7 +695,7 @@ final class RequestBagTests: XCTestCase {
         XCTAssertEqual(delegate.hitDidReceiveBodyPart, 2)
 
         // the remote closes the connection, which leads to more data and a succeed of the request
-        bag.succeedRequest([ByteBuffer(string: "baz")])
+        bag.receiveResponseEnd([ByteBuffer(string: "baz")], trailers: nil)
         XCTAssertEqual(delegate.hitDidReceiveBodyPart, 2)
 
         XCTAssertNoThrow(try XCTUnwrap(delegate.backpressurePromise).succeed(()))
@@ -785,7 +785,7 @@ final class RequestBagTests: XCTestCase {
 
         XCTAssertEqual(delegate.hitDidReceiveBodyPart, 0)
         XCTAssertFalse(executor.signalledDemandForResponseBody)
-        bag.succeedRequest([ByteBuffer(repeating: 2, count: 1024)])
+        bag.receiveResponseEnd([ByteBuffer(repeating: 2, count: 1024)], trailers: nil)
         XCTAssertFalse(executor.signalledDemandForResponseBody)
         XCTAssertEqual(delegate.hitDidReceiveResponse, 0)
         XCTAssertNil(delegate.backpressurePromise)
diff --git a/Tests/AsyncHTTPClientTests/TransactionTests.swift b/Tests/AsyncHTTPClientTests/TransactionTests.swift
@@ -174,7 +174,7 @@ final class TransactionTests: XCTestCase {
             async let part = iterator.next()
             XCTAssertNoThrow(try executor.receiveResponseDemand())
             executor.resetResponseStreamDemandSignal()
-            transaction.succeedRequest([])
+            transaction.receiveResponseEnd([], trailers: nil)
             let result = try await part
             XCTAssertNil(result)
         }
@@ -225,7 +225,7 @@ final class TransactionTests: XCTestCase {
 
             // doesn't crash if receives more data because of race
             transaction.receiveResponseBodyParts([ByteBuffer(string: "foo bar")])
-            transaction.succeedRequest(nil)
+            transaction.receiveResponseEnd(nil, trailers: nil)
         }
     }
 
@@ -297,7 +297,7 @@ final class TransactionTests: XCTestCase {
 
             XCTAssertNoThrow(try executor.receiveResponseDemand())
             executor.resetResponseStreamDemandSignal()
-            transaction.succeedRequest([])
+            transaction.receiveResponseEnd([], trailers: nil)
             let result = try await part
             XCTAssertNil(result)
         }
@@ -391,7 +391,7 @@ final class TransactionTests: XCTestCase {
 
             let responseHead = HTTPResponseHead(version: .http1_1, status: .ok, headers: ["foo": "bar"])
             transaction.receiveResponseHead(responseHead)
-            transaction.succeedRequest(nil)
+            transaction.receiveResponseEnd(nil, trailers: nil)
 
             let response = try await responseTask.value
             XCTAssertEqual(response.status, .ok)

Original file line number	Diff line number	Diff line change
`@@ -286,11 +286,11 @@ extension Transaction: HTTPExecutableRequest {`
`286`	`286`	`}`
`287`	`287`	`}`
`288`	`288`
`289`		`- func succeedRequest(_ buffer: CircularBuffer<ByteBuffer>?) {`
`290`		`- let succeedAction = self.state.withLockedValue { state in`
`291`		`- state.succeedRequest(buffer)`
	`289`	`+ func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {`
	`290`	`+ let receiveResponseEndAction = self.state.withLockedValue { state in`
	`291`	`+ state.receiveResponseEnd(buffer)`
`292`	`292`	`}`
`293`		`- switch succeedAction {`
	`293`	`+ switch receiveResponseEndAction {`
`294`	`294`	`case .finishResponseStream(let source, let finalResponse):`
`295`	`295`	`if let finalResponse = finalResponse {`
`296`	`296`	`_ = source.yield(contentsOf: finalResponse)`
Original file line number	Diff line number	Diff line change
`@@ -401,7 +401,7 @@ extension RequestBag.StateMachine {`
`401`	`401`	`case none`
`402`	`402`	`}`
`403`	`403`
`404`		`- mutating func succeedRequest(_ newChunks: CircularBuffer<ByteBuffer>?) -> ReceiveResponseEndAction {`
	`404`	`+ mutating func receiveResponseEnd(_ newChunks: CircularBuffer<ByteBuffer>?) -> ReceiveResponseEndAction {`
`405`	`405`	`switch self.state {`
`406`	`406`	`case .initialized, .queued, .deadlineExceededWhileQueued:`
`407`	`407`	`preconditionFailure("How can we receive a response body part, if the request hasn't started yet.")`
Original file line number	Diff line number	Diff line change
`@@ -306,8 +306,8 @@ final class RequestBag<Delegate: HTTPClientResponseDelegate & Sendable>: Sendabl`
`306`	`306`	`}`
`307`	`307`	`}`
`308`	`308`
`309`		`- private func succeedRequest0(_ buffer: CircularBuffer<ByteBuffer>?) {`
`310`		`- let action = self.loopBoundState.value.state.succeedRequest(buffer)`
	`309`	`+ private func receiveResponseEnd0(_ buffer: CircularBuffer<ByteBuffer>?) {`
	`310`	`+ let action = self.loopBoundState.value.state.receiveResponseEnd(buffer)`
`311`	`311`
`312`	`312`	`switch action {`
`313`	`313`	`case .none:`
`@@ -538,12 +538,12 @@ extension RequestBag: HTTPExecutableRequest {`
`538`	`538`	`}`
`539`	`539`	`}`
`540`	`540`
`541`		`- func succeedRequest(_ buffer: CircularBuffer<ByteBuffer>?) {`
	`541`	`+ func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {`
`542`	`542`	`if self.task.eventLoop.inEventLoop {`
`543`		`- self.succeedRequest0(buffer)`
	`543`	`+ self.receiveResponseEnd0(buffer)`
`544`	`544`	`} else {`
`545`	`545`	`self.task.eventLoop.execute {`
`546`		`- self.succeedRequest0(buffer)`
	`546`	`+ self.receiveResponseEnd0(buffer)`
`547`	`547`	`}`
`548`	`548`	`}`
`549`	`549`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ final private class MockScheduledRequest: HTTPSchedulableRequest {`
`134`	`134`	`preconditionFailure("Unimplemented")`
`135`	`135`	`}`
`136`	`136`
`137`		`- func succeedRequest(_: CircularBuffer<ByteBuffer>?) {`
	`137`	`+ func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {`
`138`	`138`	`preconditionFailure("Unimplemented")`
`139`	`139`	`}`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -757,7 +757,7 @@ final class MockHTTPScheduableRequest: HTTPSchedulableRequest {`
`757`	`757`	`preconditionFailure("Unimplemented")`
`758`	`758`	`}`
`759`	`759`
`760`		`- func succeedRequest(_: CircularBuffer<ByteBuffer>?) {`
	`760`	`+ func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {`
`761`	`761`	`preconditionFailure("Unimplemented")`
`762`	`762`	`}`
`763`	`763`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ final class MockHTTPExecutableRequest: HTTPExecutableRequest {`
`157`	`157`	`receiveResponseBodyPartsCallback(buffer)`
`158`	`158`	`}`
`159`	`159`
`160`		`- func succeedRequest(_ buffer: CircularBuffer<NIOCore.ByteBuffer>?) {`
	`160`	`+ func receiveResponseEnd(_ buffer: CircularBuffer<ByteBuffer>?, trailers: HTTPHeaders?) {`
`161`	`161`	`self.events.append(.succeedRequest(buffer))`
`162`	`162`	`guard let succeedRequestCallback = succeedRequestCallback else {`
`163`	`163`	`return self.calledUnimplementedMethod(#function)`