add continuation to AsyncRequestBag.init

tests still need to migrate to the new init

Author: dnadoba

Sources/AsyncHTTPClient/AsyncAwait/AsyncRequestBag.swift

@@ -41,7 +41,8 @@ class AsyncRequestBag {
         requestOptions: RequestOptions,
         logger: Logger,
         connectionDeadline: NIODeadline,
-        preferredEventLoop: EventLoop
+        preferredEventLoop: EventLoop,
+        responseContinuation: UnsafeContinuation<HTTPClientResponse, Error>
     ) throws {
         self.request = request
         self.requestOptions = requestOptions
@@ -53,6 +54,8 @@ class AsyncRequestBag {
         self.poolKey = validatedRequest.poolKey
         self.requestHead = validatedRequest.head
         self.requestFramingMetadata = validatedRequest.requestFramingMetadata
+        
+        self.state.registerContinuation(responseContinuation)
     }
 
     func result() async throws -> HTTPClientResponse {

Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift

@@ -191,26 +191,70 @@ extension HTTPClientResponse.Body: AsyncSequence {
 @available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)
 extension HTTPClient {
     func execute(_ request: HTTPClientRequest, deadline: NIODeadline, logger: Logger) async throws -> HTTPClientResponse {
-        let bag = try AsyncRequestBag(
-            request: request,
-            requestOptions: .init(idleReadTimeout: nil),
-            logger: logger,
-            connectionDeadline: .now() + .seconds(10),
-            preferredEventLoop: self.eventLoopGroup.next()
-        )
-
-        return try await withTaskCancellationHandler {
-            bag.cancel()
-        } operation: { () -> HTTPClientResponse in
-            // first register the completion
-            async let result = bag.result()
-
-            // second throw it onto the connection pool for execution
-            self.poolManager.executeRequest(bag)
-
-            // third await result
-            return try await result
+        actor SwiftCancellationHandlingSucksAsFuck {
+            
+            enum State {
+                case initialized
+                case register(AsyncRequestBag)
+                case cancelled
+            }
+            
+            private var state: State = .initialized
+            
+            init() {}
+            
+            func registerRequestBag(_ bag: AsyncRequestBag) {
+                switch self.state {
+                case .initialized:
+                    self.state = .register(bag)
+                case .cancelled:
+                    bag.cancel()
+                case .register:
+                    preconditionFailure()
+                }
+            }
+            
+            func cancel() {
+                switch self.state {
+                case .register(let bag):
+                    self.state = .cancelled
+                    bag.cancel()
+                case .cancelled:
+                    break
+                case .initialized:
+                    self.state = .cancelled
+                }
+            }
         }
+        
+        let cancelHandler = SwiftCancellationHandlingSucksAsFuck()
+        
+        //let onCancel: @Sendable () -> () =
+        
+        return try await withTaskCancellationHandler(operation: { () async throws -> HTTPClientResponse in
+            try await withUnsafeThrowingContinuation{
+                (continuation: UnsafeContinuation<HTTPClientResponse, Swift.Error>) -> Void in
+                
+                let bag = try! AsyncRequestBag(
+                    request: request,
+                    requestOptions: .init(idleReadTimeout: nil),
+                    logger: logger,
+                    connectionDeadline: .now() + .seconds(10),
+                    preferredEventLoop: self.eventLoopGroup.next(),
+                    responseContinuation: continuation
+                )
+                
+                _Concurrency.Task {
+                    await cancelHandler.registerRequestBag(bag)
+                }
+                
+                self.poolManager.executeRequest(bag)
+            }
+        }, onCancel: {
+            _Concurrency.Task {
+                await cancelHandler.cancel()
+            }
+        })
     }
 }
 

Tests/AsyncHTTPClientTests/AsyncRequestTests.swift

@@ -29,16 +29,22 @@ final class AsyncRequestTests: XCTestCase {
         request.method = .GET
 
         var maybeRequestBag: AsyncRequestBag?
-        XCTAssertNoThrow(maybeRequestBag = try AsyncRequestBag(
-            request: request,
-            requestOptions: .forTests(),
-            logger: logger,
-            connectionDeadline: .distantFuture,
-            preferredEventLoop: embeddedEventLoop
-        ))
-        guard let requestBag = maybeRequestBag else { return XCTFail("unexpectedly found nil") }
+        var requestBagPromise = embeddedEventLoop.makePromise(of: AsyncRequestBag.self)
+        async let result = withUnsafeContinuation { (continuation: UnsafeContinuation<HTTPClientResponse, Error>) in
+            let requestBag = try AsyncRequestBag(
+                request: request,
+                requestOptions: .forTests(),
+                logger: logger,
+                connectionDeadline: .distantFuture,
+                preferredEventLoop: embeddedEventLoop
+            )
+            requestBagPromise.succeed(requestBag)
+        }
+        
+        
+
+//        guard let requestBag = maybeRequestBag else { return XCTFail("unexpectedly found nil") }
 
-        async let result = requestBag.result()
 
         Task.detached {
             try await Task.sleep(nanoseconds: 5 * 1000 * 1000)