Merge branch 'main' into debug-initializer

Author: dnadoba

.github/workflows/main.yml

@@ -14,5 +14,10 @@ jobs:
             linux_5_9_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error"
             linux_5_10_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error"
             linux_6_0_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
-            linux_nightly_6_0_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
+            linux_nightly_next_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
             linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
+
+    static-sdk:
+        name: Static SDK
+        # Workaround https://github.com/nektos/act/issues/1875
+        uses: apple/swift-nio/.github/workflows/static_sdk.yml@main

.github/workflows/pull_request.yml

@@ -17,9 +17,14 @@ jobs:
             linux_5_9_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error"
             linux_5_10_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error"
             linux_6_0_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
-            linux_nightly_6_0_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
+            linux_nightly_next_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
             linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
 
     cxx-interop:
         name: Cxx interop
         uses: apple/swift-nio/.github/workflows/cxx_interop.yml@main
+
+    static-sdk:
+        name: Static SDK
+        # Workaround https://github.com/nektos/act/issues/1875
+        uses: apple/swift-nio/.github/workflows/static_sdk.yml@main

Package.swift

@@ -86,11 +86,16 @@ let package = Package(
 
 // ---    STANDARD CROSS-REPO SETTINGS DO NOT EDIT   --- //
 for target in package.targets {
-    if target.type != .plugin {
+    switch target.type {
+    case .regular, .test, .executable:
         var settings = target.swiftSettings ?? []
         // https://github.com/swiftlang/swift-evolution/blob/main/proposals/0444-member-import-visibility.md
         settings.append(.enableUpcomingFeature("MemberImportVisibility"))
         target.swiftSettings = settings
+    case .macro, .plugin, .system, .binary:
+        ()  // not applicable
+    @unknown default:
+        ()  // we don't know what to do here, do nothing
     }
 }
 // --- END: STANDARD CROSS-REPO SETTINGS DO NOT EDIT --- //

Sources/AsyncHTTPClient/AsyncAwait/HTTPClient+execute.swift

@@ -26,6 +26,10 @@ extension HTTPClient {
     ///   - request: HTTP request to execute.
     ///   - deadline: Point in time by which the request must complete.
     ///   - logger: The logger to use for this request.
+    ///
+    /// - warning: This method may violates Structured Concurrency because it returns a `HTTPClientResponse` that needs to be
+    ///            streamed by the user. This means the request, the connection and other resources are still alive when the request returns.
+    ///
     /// - Returns: The response to the request. Note that the `body` of the response may not yet have been fully received.
     public func execute(
         _ request: HTTPClientRequest,
@@ -51,6 +55,10 @@ extension HTTPClient {
     ///   - request: HTTP request to execute.
     ///   - timeout: time the the request has to complete.
     ///   - logger: The logger to use for this request.
+    ///
+    /// - warning: This method may violates Structured Concurrency because it returns a `HTTPClientResponse` that needs to be
+    ///            streamed by the user. This means the request, the connection and other resources are still alive when the request returns.
+    ///
     /// - Returns: The response to the request. Note that the `body` of the response may not yet have been fully received.
     public func execute(
         _ request: HTTPClientRequest,
@@ -67,6 +75,8 @@ extension HTTPClient {
 
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
 extension HTTPClient {
+    /// - warning: This method may violates Structured Concurrency because it returns a `HTTPClientResponse` that needs to be
+    ///            streamed by the user. This means the request, the connection and other resources are still alive when the request returns.
     private func executeAndFollowRedirectsIfNeeded(
         _ request: HTTPClientRequest,
         deadline: NIODeadline,
@@ -75,11 +85,29 @@ extension HTTPClient {
     ) async throws -> HTTPClientResponse {
         var currentRequest = request
         var currentRedirectState = redirectState
+        var history: [HTTPClientRequestResponse] = []
 
         // this loop is there to follow potential redirects
         while true {
             let preparedRequest = try HTTPClientRequest.Prepared(currentRequest, dnsOverride: configuration.dnsOverride)
-            let response = try await self.executeCancellable(preparedRequest, deadline: deadline, logger: logger)
+            let response = try await {
+                var response = try await self.executeCancellable(preparedRequest, deadline: deadline, logger: logger)
+
+                history.append(
+                    .init(
+                        request: currentRequest,
+                        responseHead: .init(
+                            version: response.version,
+                            status: response.status,
+                            headers: response.headers
+                        )
+                    )
+                )
+
+                response.history = history
+
+                return response
+            }()
 
             guard var redirectState = currentRedirectState else {
                 // a `nil` redirectState means we should not follow redirects
@@ -116,6 +144,8 @@ extension HTTPClient {
         }
     }
 
+    /// - warning: This method may violates Structured Concurrency because it returns a `HTTPClientResponse` that needs to be
+    ///            streamed by the user. This means the request, the connection and other resources are still alive when the request returns.
     private func executeCancellable(
         _ request: HTTPClientRequest.Prepared,
         deadline: NIODeadline,

Sources/AsyncHTTPClient/AsyncAwait/HTTPClientResponse.swift

@@ -15,6 +15,8 @@
 import NIOCore
 import NIOHTTP1
 
+import struct Foundation.URL
+
 /// A representation of an HTTP response for the Swift Concurrency HTTPClient API.
 ///
 /// This object is similar to ``HTTPClient/Response``, but used for the Swift Concurrency API.
@@ -32,6 +34,18 @@ public struct HTTPClientResponse: Sendable {
     /// The body of this HTTP response.
     public var body: Body
 
+    /// The history of all requests and responses in redirect order.
+    public var history: [HTTPClientRequestResponse]
+
+    /// The target URL (after redirects) of the response.
+    public var url: URL? {
+        guard let lastRequestURL = self.history.last?.request.url else {
+            return nil
+        }
+
+        return URL(string: lastRequestURL)
+    }
+
     @inlinable public init(
         version: HTTPVersion = .http1_1,
         status: HTTPResponseStatus = .ok,
@@ -42,14 +56,30 @@ public struct HTTPClientResponse: Sendable {
         self.status = status
         self.headers = headers
         self.body = body
+        self.history = []
+    }
+
+    @inlinable public init(
+        version: HTTPVersion = .http1_1,
+        status: HTTPResponseStatus = .ok,
+        headers: HTTPHeaders = [:],
+        body: Body = Body(),
+        history: [HTTPClientRequestResponse] = []
+    ) {
+        self.version = version
+        self.status = status
+        self.headers = headers
+        self.body = body
+        self.history = history
     }
 
     init(
         requestMethod: HTTPMethod,
         version: HTTPVersion,
         status: HTTPResponseStatus,
         headers: HTTPHeaders,
-        body: TransactionBody
+        body: TransactionBody,
+        history: [HTTPClientRequestResponse]
     ) {
         self.init(
             version: version,
@@ -64,11 +94,23 @@ public struct HTTPClientResponse: Sendable {
                         status: status
                     )
                 )
-            )
+            ),
+            history: history
         )
     }
 }
 
+@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+public struct HTTPClientRequestResponse: Sendable {
+    public var request: HTTPClientRequest
+    public var responseHead: HTTPResponseHead
+
+    public init(request: HTTPClientRequest, responseHead: HTTPResponseHead) {
+        self.request = request
+        self.responseHead = responseHead
+    }
+}
+
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
 extension HTTPClientResponse {
     /// A representation of the response body for an HTTP response.

Sources/AsyncHTTPClient/AsyncAwait/Transaction.swift

@@ -242,7 +242,8 @@ extension Transaction: HTTPExecutableRequest {
                 version: head.version,
                 status: head.status,
                 headers: head.headers,
-                body: body
+                body: body,
+                history: []
             )
             continuation.resume(returning: response)
         }

Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift

@@ -314,6 +314,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
             let oldRequest = self.request!
             self.request = nil
             self.runTimeoutAction(.clearIdleReadTimeoutTimer, context: context)
+            self.runTimeoutAction(.clearIdleWriteTimeoutTimer, context: context)
 
             switch finalAction {
             case .close:
@@ -353,6 +354,7 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
             let oldRequest = self.request!
             self.request = nil
             self.runTimeoutAction(.clearIdleReadTimeoutTimer, context: context)
+            self.runTimeoutAction(.clearIdleWriteTimeoutTimer, context: context)
 
             switch finalAction {
             case .close(let writePromise):

Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ConnectionStateMachine.swift

@@ -359,7 +359,7 @@ struct HTTP1ConnectionStateMachine {
 
     mutating func idleWriteTimeoutTriggered() -> Action {
         guard case .inRequest(var requestStateMachine, let close) = self.state else {
-            preconditionFailure("Invalid state: \(self.state)")
+            return .wait
         }
 
         return self.avoidingStateMachineCoW { state -> Action in

Sources/AsyncHTTPClient/ConnectionPool/HTTP2/HTTP2ClientRequestHandler.swift

@@ -240,6 +240,7 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
             self.request!.fail(error)
             self.request = nil
             self.runTimeoutAction(.clearIdleReadTimeoutTimer, context: context)
+            self.runTimeoutAction(.clearIdleWriteTimeoutTimer, context: context)
             // No matter the error reason, we must always make sure the h2 stream is closed. Only
             // once the h2 stream is closed, it is released from the h2 multiplexer. The
             // HTTPRequestStateMachine may signal finalAction: .none in the error case (as this is
@@ -252,6 +253,7 @@ final class HTTP2ClientRequestHandler: ChannelDuplexHandler {
             self.request!.succeedRequest(finalParts)
             self.request = nil
             self.runTimeoutAction(.clearIdleReadTimeoutTimer, context: context)
+            self.runTimeoutAction(.clearIdleWriteTimeoutTimer, context: context)
             self.runSuccessfulFinalAction(finalAction, context: context)
 
         case .failSendBodyPart(let error, let writePromise), .failSendStreamFinished(let error, let writePromise):

Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool+Factory.swift

@@ -22,6 +22,7 @@ import NIOSSL
 import NIOTLS
 
 #if canImport(Network)
+import Network
 import NIOTransportServices
 #endif
 

Sources/AsyncHTTPClient/FileDownloadDelegate.swift

@@ -16,16 +16,47 @@ import NIOCore
 import NIOHTTP1
 import NIOPosix
 
+import struct Foundation.URL
+
 /// Handles a streaming download to a given file path, allowing headers and progress to be reported.
 public final class FileDownloadDelegate: HTTPClientResponseDelegate {
     /// The response type for this delegate: the total count of bytes as reported by the response
-    /// "Content-Length" header (if available) and the count of bytes downloaded.
+    /// "Content-Length" header (if available), the count of bytes downloaded, the
+    /// response head, and a history of requests and responses.
     public struct Progress: Sendable {
         public var totalBytes: Int?
         public var receivedBytes: Int
+
+        /// The history of all requests and responses in redirect order.
+        public var history: [HTTPClient.RequestResponse] = []
+
+        /// The target URL (after redirects) of the response.
+        public var url: URL? {
+            self.history.last?.request.url
+        }
+
+        public var head: HTTPResponseHead {
+            get {
+                assert(self._head != nil)
+                return self._head!
+            }
+            set {
+                self._head = newValue
+            }
+        }
+
+        fileprivate var _head: HTTPResponseHead? = nil
+
+        internal init(totalBytes: Int? = nil, receivedBytes: Int) {
+            self.totalBytes = totalBytes
+            self.receivedBytes = receivedBytes
+        }
     }
 
-    private var progress = Progress(totalBytes: nil, receivedBytes: 0)
+    private var progress = Progress(
+        totalBytes: nil,
+        receivedBytes: 0
+    )
 
     public typealias Response = Progress
 
@@ -129,10 +160,16 @@ public final class FileDownloadDelegate: HTTPClientResponseDelegate {
         )
     }
 
+    public func didVisitURL(task: HTTPClient.Task<Progress>, _ request: HTTPClient.Request, _ head: HTTPResponseHead) {
+        self.progress.history.append(.init(request: request, responseHead: head))
+    }
+
     public func didReceiveHead(
         task: HTTPClient.Task<Response>,
         _ head: HTTPResponseHead
     ) -> EventLoopFuture<Void> {
+        self.progress._head = head
+
         self.reportHead?(task, head)
 
         if let totalBytesString = head.headers.first(name: "Content-Length"),