NIO Transport Services

Choose NIOTSConnectionBootstrap or ClientBootstrap based on the EventLoop passed to the client.

Co-authored-by: Joe Smith <[email protected]>
Co-authored-by: Johannes Weiss <[email protected]>

Author: 3 people

Package.swift

@@ -17,18 +17,20 @@ import PackageDescription
 
 let package = Package(
     name: "async-http-client",
+    platforms: [.iOS(.v12), .tvOS(.v12)],
     products: [
         .library(name: "AsyncHTTPClient", targets: ["AsyncHTTPClient"]),
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-nio.git", from: "2.13.1"),
         .package(url: "https://github.com/apple/swift-nio-ssl.git", from: "2.4.1"),
         .package(url: "https://github.com/apple/swift-nio-extras.git", from: "1.3.0"),
+        .package(url: "https://github.com/adam-fowler/swift-nio-transport-services.git", .branch("master")),
     ],
     targets: [
         .target(
             name: "AsyncHTTPClient",
-            dependencies: ["NIO", "NIOHTTP1", "NIOSSL", "NIOConcurrencyHelpers", "NIOHTTPCompression", "NIOFoundationCompat"]
+            dependencies: ["NIO", "NIOHTTP1", "NIOSSL", "NIOConcurrencyHelpers", "NIOHTTPCompression", "NIOFoundationCompat", "NIOTransportServices"]
         ),
         .testTarget(
             name: "AsyncHTTPClientTests",

Sources/AsyncHTTPClient/ConnectionPool.swift

@@ -16,6 +16,8 @@ import Foundation
 import NIO
 import NIOConcurrencyHelpers
 import NIOHTTP1
+import NIOSSL
+import NIOTransportServices
 import NIOTLS
 
 /// A connection pool that manages and creates new connections to hosts respecting the specified preferences
@@ -368,11 +370,58 @@ final class ConnectionPool {
             }
         }
 
+        private func makeNonTSBootstrap(on eventLoop: EventLoop) throws -> NIOClientTCPBootstrap {
+            let tlsConfiguration = configuration.tlsConfiguration ?? TLSConfiguration.forClient()
+            let sslContext = try NIOSSLContext(configuration: tlsConfiguration)
+            let tlsProvider = try NIOSSLClientTLSProvider<ClientBootstrap>(context: sslContext, serverHostname: key.host.isIPAddress ? nil : key.host)
+            return NIOClientTCPBootstrap(ClientBootstrap(group: eventLoop), tls: tlsProvider)
+        }
+        
+        /// create a TCP Bootstrap based off what type of `EventLoop` has been passed to the function.
+        private func makeBootstrap(on eventLoop: EventLoop) throws -> NIOClientTCPBootstrap {
+            let bootstrap: NIOClientTCPBootstrap
+            #if canImport(Network)
+            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), eventLoop is NIOTSEventLoop {
+                let tlsProvider = NIOTSClientTLSProvider(tlsOptions: .init())
+                bootstrap = NIOClientTCPBootstrap(NIOTSConnectionBootstrap(group: eventLoop), tls: tlsProvider)
+            } else {
+                bootstrap = try makeNonTSBootstrap(on: eventLoop)
+            }
+            #else
+            bootstrap = try makeNonTSBootstrap(on: eventLoop)
+            #endif
+
+            if key.scheme == .https {
+                return bootstrap.enableTLS()
+            }
+            return bootstrap
+        }
+        
+        private func makeHTTPClientBootstrapBase(on eventLoop: EventLoop) throws -> NIOClientTCPBootstrap {
+            return try makeBootstrap(on: eventLoop)
+                .channelOption(ChannelOptions.socket(SocketOptionLevel(IPPROTO_TCP), TCP_NODELAY), value: 1)
+                .channelInitializer { channel in
+                    let channelAddedFuture: EventLoopFuture<Void>
+                    switch self.configuration.proxy {
+                    case .none:
+                        channelAddedFuture = eventLoop.makeSucceededFuture(())
+                    case .some:
+                        channelAddedFuture = channel.pipeline.addProxyHandler(host: self.key.host, port: self.key.port, authorization: self.configuration.proxy?.authorization)
+                    }
+                    return channelAddedFuture
+                }
+        }
+        
         private func makeConnection(on eventLoop: EventLoop) -> EventLoopFuture<Connection> {
             self.activityPrecondition(expected: [.opened])
             let handshakePromise = eventLoop.makePromise(of: Void.self)
-            let bootstrap = ClientBootstrap.makeHTTPClientBootstrapBase(group: eventLoop, host: self.key.host, port: self.key.port, configuration: self.configuration)
             let address = HTTPClient.resolveAddress(host: self.key.host, port: self.key.port, proxy: self.configuration.proxy)
+            let bootstrap : NIOClientTCPBootstrap
+            do {
+                bootstrap = try makeHTTPClientBootstrapBase(on: eventLoop)
+            } catch {
+                return eventLoop.makeFailedFuture(error)
+            }
 
             let channel: EventLoopFuture<Channel>
             switch self.key.scheme {
@@ -383,7 +432,8 @@ final class ConnectionPool {
             }
 
             return channel.flatMap { channel -> EventLoopFuture<ConnectionPool.Connection> in
-                channel.pipeline.addSSLHandlerIfNeeded(for: self.key, tlsConfiguration: self.configuration.tlsConfiguration, handshakePromise: handshakePromise)
+                handshakePromise.succeed(())
+//                channel.pipeline.addSSLHandlerIfNeeded(for: self.key, tlsConfiguration: self.configuration.tlsConfiguration, handshakePromise: handshakePromise)
                 return handshakePromise.futureResult.flatMap {
                     channel.pipeline.addHTTPClientHandlers(leftOverBytesStrategy: .forwardBytes)
                 }.map {

Sources/AsyncHTTPClient/HTTPClient.swift

@@ -18,6 +18,7 @@ import NIOConcurrencyHelpers
 import NIOHTTP1
 import NIOHTTPCompression
 import NIOSSL
+import NIOTransportServices
 import NIOTLS
 
 /// HTTPClient class provides API for request execution.
@@ -65,7 +66,15 @@ public class HTTPClient {
         case .shared(let group):
             self.eventLoopGroup = group
         case .createNew:
+            #if canImport(Network)
+            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *) {
+                self.eventLoopGroup = NIOTSEventLoopGroup()
+            } else {
+                self.eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+            }
+            #else
             self.eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+            #endif
         }
         self.configuration = configuration
         self.pool = ConnectionPool(configuration: configuration)

Sources/AsyncHTTPClient/Utils.swift

@@ -46,26 +46,6 @@ public final class HTTPClientCopyingDelegate: HTTPClientResponseDelegate {
     }
 }
 
-extension ClientBootstrap {
-    static func makeHTTPClientBootstrapBase(group: EventLoopGroup, host: String, port: Int, configuration: HTTPClient.Configuration, channelInitializer: ((Channel) -> EventLoopFuture<Void>)? = nil) -> ClientBootstrap {
-        return ClientBootstrap(group: group)
-            .channelOption(ChannelOptions.socket(SocketOptionLevel(IPPROTO_TCP), TCP_NODELAY), value: 1)
-
-            .channelInitializer { channel in
-                let channelAddedFuture: EventLoopFuture<Void>
-                switch configuration.proxy {
-                case .none:
-                    channelAddedFuture = group.next().makeSucceededFuture(())
-                case .some:
-                    channelAddedFuture = channel.pipeline.addProxyHandler(host: host, port: port, authorization: configuration.proxy?.authorization)
-                }
-                return channelAddedFuture.flatMap { (_: Void) -> EventLoopFuture<Void> in
-                    channelInitializer?(channel) ?? group.next().makeSucceededFuture(())
-                }
-            }
-    }
-}
-
 extension CircularBuffer {
     @discardableResult
     mutating func swapWithFirstAndRemove(at index: Index) -> Element? {

Tests/AsyncHTTPClientTests/HTTPClientInternalTests.swift

@@ -217,7 +217,9 @@ class HTTPClientInternalTests: XCTestCase {
             func didFinishRequest(task: HTTPClient.Task<Response>) throws {}
         }
 
-        let httpClient = HTTPClient(eventLoopGroupProvider: .createNew)
+        // cannot test with NIOTS as `maxMessagesPerRead` is not supported
+        let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        let httpClient = HTTPClient(eventLoopGroupProvider: .shared(eventLoopGroup))
         let promise = httpClient.eventLoopGroup.next().makePromise(of: Channel.self)
         let httpBin = HTTPBin(channelPromise: promise)
 

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -730,7 +730,7 @@ class HTTPClientTests: XCTestCase {
         }
 
         XCTAssertThrowsError(try httpClient.get(url: "https://localhost:\(httpBin.port)/redirect/infinite1").wait(), "Should fail with redirect limit") { error in
-            XCTAssertEqual(error as! HTTPClientError, HTTPClientError.redirectCycleDetected)
+            XCTAssertEqual(error as? HTTPClientError, HTTPClientError.redirectCycleDetected)
         }
     }
 
@@ -745,7 +745,7 @@ class HTTPClientTests: XCTestCase {
         }
 
         XCTAssertThrowsError(try httpClient.get(url: "https://localhost:\(httpBin.port)/redirect/infinite1").wait(), "Should fail with redirect limit") { error in
-            XCTAssertEqual(error as! HTTPClientError, HTTPClientError.redirectLimitReached)
+            XCTAssertEqual(error as? HTTPClientError, HTTPClientError.redirectLimitReached)
         }
     }