Add a ConnectionPool.Host enum

Author: karwa

Sources/AsyncHTTPClient/ConnectionPool.swift

@@ -12,42 +12,72 @@
 //
 //===----------------------------------------------------------------------===//
 
+import enum NIOCore.SocketAddress
+
 enum ConnectionPool {
+
+    enum Host: Hashable {
+        // We keep the IP address serialization precisely as it is in the URL.
+        // Some platforms have quirks in their implementations of 'ntop', for example
+        // writing IPv6 addresses as having embedded IPv4 sections (e.g. [::192.168.0.1] vs [::c0a8:1]).
+        // This serialization includes square brackets, so it is safe to write next to a port number.
+        // Note: `address` must always have a non-nil port.
+        case ipAddress(serialization: String, address: SocketAddress)
+        case domain(name: String, port: Int)
+        case unixSocket(path: String)
+
+        init(remoteHost: String, port: Int) {
+            if let addr = try? SocketAddress(ipAddress: remoteHost, port: port) {
+                switch addr {
+                case .v6:
+                    self = .ipAddress(serialization: "[\(remoteHost)]", address: addr)
+                case .v4:
+                    self = .ipAddress(serialization: remoteHost, address: addr)
+                case .unixDomainSocket:
+                    fatalError("Expected a remote host")
+                }
+            } else {
+                precondition(!remoteHost.isEmpty, "HTTPClient.Request should already reject empty remote hostnames")
+                self = .domain(name: remoteHost, port: port)
+            }
+        }
+    }
+
     /// Used by the `ConnectionPool` to index its `HTTP1ConnectionProvider`s
     ///
     /// A key is initialized from a `URL`, it uses the components to derive a hashed value
     /// used by the `providers` dictionary to allow retrieving and creating
     /// connection providers associated to a certain request in constant time.
     struct Key: Hashable, CustomStringConvertible {
+        var scheme: Scheme
+        var host: Host
+        private var tlsConfiguration: BestEffortHashableTLSConfiguration?
+
         init(_ request: HTTPClient.Request) {
             switch request.scheme {
             case "http":
                 self.scheme = .http
+                self.host = Host(remoteHost: request.host, port: request.port)
             case "https":
                 self.scheme = .https
+                self.host = Host(remoteHost: request.host, port: request.port)
             case "unix":
                 self.scheme = .unix
+                self.host = .unixSocket(path: request.socketPath)
             case "http+unix":
                 self.scheme = .http_unix
+                self.host = .unixSocket(path: request.socketPath)
             case "https+unix":
                 self.scheme = .https_unix
+                self.host = .unixSocket(path: request.socketPath)
             default:
                 fatalError("HTTPClient.Request scheme should already be a valid one")
             }
-            self.port = request.port
-            self.host = request.host
-            self.unixPath = request.socketPath
             if let tls = request.tlsConfiguration {
                 self.tlsConfiguration = BestEffortHashableTLSConfiguration(wrapping: tls)
             }
         }
 
-        var scheme: Scheme
-        var host: String
-        var port: Int
-        var unixPath: String
-        private var tlsConfiguration: BestEffortHashableTLSConfiguration?
-
         enum Scheme: Hashable {
             case http
             case https
@@ -78,13 +108,16 @@ enum ConnectionPool {
             var hasher = Hasher()
             self.tlsConfiguration?.hash(into: &hasher)
             let hash = hasher.finalize()
-            var path = ""
-            if self.unixPath != "" {
-                path = self.unixPath
-            } else {
-                path = "\(self.host):\(self.port)"
+            var hostDescription = ""
+            switch host {
+            case .ipAddress(let serialization, let addr):
+                hostDescription = "\(serialization):\(addr.port!)"
+            case .domain(let domain, port: let port):
+                hostDescription = "\(domain):\(port)"
+            case .unixSocket(let socketPath):
+                hostDescription = socketPath
             }
-            return "\(self.scheme)://\(path) TLS-hash: \(hash)"
+            return "\(self.scheme)://\(hostDescription) TLS-hash: \(hash)"
         }
     }
 }

Sources/AsyncHTTPClient/ConnectionPool/ChannelHandler/HTTP1ProxyConnectHandler.swift

@@ -45,6 +45,30 @@ final class HTTP1ProxyConnectHandler: ChannelDuplexHandler, RemovableChannelHand
         return self.proxyEstablishedPromise?.futureResult
     }
 
+    convenience
+    init(target: ConnectionPool.Host,
+         proxyAuthorization: HTTPClient.Authorization?,
+         deadline: NIODeadline) {
+        let targetHost: String
+        let targetPort: Int
+        switch target {
+        case .ipAddress(serialization: let serialization, address: let address):
+            targetHost = serialization
+            targetPort = address.port!
+        case .domain(name: let domain, port: let port):
+            targetHost = domain
+            targetPort = port
+        case .unixSocket:
+            fatalError("Unix Domain Sockets do not support proxies")
+        }
+        self.init(
+            targetHost: targetHost,
+            targetPort: targetPort,
+            proxyAuthorization: proxyAuthorization,
+            deadline: deadline
+        )
+    }
+
     init(targetHost: String,
          targetPort: Int,
          proxyAuthorization: HTTPClient.Authorization?,

Sources/AsyncHTTPClient/ConnectionPool/HTTPConnectionPool+Factory.swift

@@ -197,16 +197,8 @@ extension HTTPConnectionPool.ConnectionFactory {
     }
 
     private func makePlainChannel(deadline: NIODeadline, eventLoop: EventLoop) -> EventLoopFuture<Channel> {
-        let bootstrap = self.makePlainBootstrap(deadline: deadline, eventLoop: eventLoop)
-
-        switch self.key.scheme {
-        case .http:
-            return bootstrap.connect(host: self.key.host, port: self.key.port)
-        case .http_unix, .unix:
-            return bootstrap.connect(unixDomainSocketPath: self.key.unixPath)
-        case .https, .https_unix:
-            preconditionFailure("Unexpected scheme")
-        }
+        precondition(!self.key.scheme.requiresTLS, "Unexpected scheme")
+        return self.makePlainBootstrap(deadline: deadline, eventLoop: eventLoop).connect(host: self.key.host)
     }
 
     private func makeHTTPProxyChannel(
@@ -224,8 +216,7 @@ extension HTTPConnectionPool.ConnectionFactory {
             let encoder = HTTPRequestEncoder()
             let decoder = ByteToMessageHandler(HTTPResponseDecoder(leftOverBytesStrategy: .dropBytes))
             let proxyHandler = HTTP1ProxyConnectHandler(
-                targetHost: self.key.host,
-                targetPort: self.key.port,
+                target: self.key.host,
                 proxyAuthorization: proxy.authorization,
                 deadline: deadline
             )
@@ -264,7 +255,7 @@ extension HTTPConnectionPool.ConnectionFactory {
         // upgraded to TLS before we send our first request.
         let bootstrap = self.makePlainBootstrap(deadline: deadline, eventLoop: eventLoop)
         return bootstrap.connect(host: proxy.host, port: proxy.port).flatMap { channel in
-            let socksConnectHandler = SOCKSClientHandler(targetAddress: .domain(self.key.host, port: self.key.port))
+            let socksConnectHandler = SOCKSClientHandler(targetAddress: SOCKSAddress(self.key.host))
             let socksEventHandler = SOCKSEventsHandler(deadline: deadline)
 
             do {
@@ -310,6 +301,7 @@ extension HTTPConnectionPool.ConnectionFactory {
             }
             let tlsEventHandler = TLSEventsHandler(deadline: deadline)
 
+            let sslServerHostname = self.key.host.sslServerHostname
             let sslContextFuture = self.sslContextCache.sslContext(
                 tlsConfiguration: tlsConfig,
                 eventLoop: channel.eventLoop,
@@ -320,7 +312,7 @@ extension HTTPConnectionPool.ConnectionFactory {
                 do {
                     let sslHandler = try NIOSSLClientHandler(
                         context: sslContext,
-                        serverHostname: self.key.host
+                        serverHostname: sslServerHostname
                     )
                     try channel.pipeline.syncOperations.addHandler(sslHandler)
                     try channel.pipeline.syncOperations.addHandler(tlsEventHandler)
@@ -364,21 +356,15 @@ extension HTTPConnectionPool.ConnectionFactory {
     }
 
     private func makeTLSChannel(deadline: NIODeadline, eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<(Channel, String?)> {
+        precondition(self.key.scheme.requiresTLS, "Unexpected scheme")
         let bootstrapFuture = self.makeTLSBootstrap(
             deadline: deadline,
             eventLoop: eventLoop,
             logger: logger
         )
 
         var channelFuture = bootstrapFuture.flatMap { bootstrap -> EventLoopFuture<Channel> in
-            switch self.key.scheme {
-            case .https:
-                return bootstrap.connect(host: self.key.host, port: self.key.port)
-            case .https_unix:
-                return bootstrap.connect(unixDomainSocketPath: self.key.unixPath)
-            case .http, .http_unix, .unix:
-                preconditionFailure("Unexpected scheme")
-            }
+            return bootstrap.connect(host: self.key.host)
         }.flatMap { channel -> EventLoopFuture<(Channel, String?)> in
             // It is save to use `try!` here, since we are sure, that a `TLSEventsHandler` exists
             // within the pipeline. It is added in `makeTLSBootstrap`.
@@ -441,9 +427,7 @@ extension HTTPConnectionPool.ConnectionFactory {
         }
         #endif
 
-        let host = self.key.host
-        let hostname = (host.isIPAddress || host.isEmpty) ? nil : host
-
+        let sslServerHostname = self.key.host.sslServerHostname
         let sslContextFuture = sslContextCache.sslContext(
             tlsConfiguration: tlsConfig,
             eventLoop: eventLoop,
@@ -458,7 +442,7 @@ extension HTTPConnectionPool.ConnectionFactory {
                         let sync = channel.pipeline.syncOperations
                         let sslHandler = try NIOSSLClientHandler(
                             context: sslContext,
-                            serverHostname: hostname
+                            serverHostname: sslServerHostname
                         )
                         let tlsEventHandler = TLSEventsHandler(deadline: deadline)
 
@@ -497,14 +481,37 @@ extension ConnectionPool.Key.Scheme {
     }
 }
 
-extension String {
-    fileprivate var isIPAddress: Bool {
-        var ipv4Addr = in_addr()
-        var ipv6Addr = in6_addr()
+extension ConnectionPool.Host {
+
+    fileprivate var sslServerHostname: String? {
+        switch self {
+        case .domain(let domain, _): return domain
+        case .ipAddress, .unixSocket: return nil
+        }
+    }
+}
+
+extension SOCKSAddress {
+
+    fileprivate init(_ host: ConnectionPool.Host) {
+        switch host {
+        case .ipAddress(_, let address): self = .address(address)
+        case .domain(let domain, let port): self = .domain(domain, port: port)
+        case .unixSocket: fatalError("Unix Domain Sockets are not supported by SOCKSAddress")
+        }
+    }
+}
+
+extension NIOClientTCPBootstrapProtocol {
 
-        return self.withCString { ptr in
-            inet_pton(AF_INET, ptr, &ipv4Addr) == 1 ||
-                inet_pton(AF_INET6, ptr, &ipv6Addr) == 1
+    func connect(host: ConnectionPool.Host) -> EventLoopFuture<Channel> {
+        switch host {
+        case .ipAddress(_, let socketAddress):
+            return self.connect(to: socketAddress)
+        case .domain(let domain, let port):
+            return self.connect(host: domain, port: port)
+        case .unixSocket(let path):
+            return self.connect(unixDomainSocketPath: path)
         }
     }
 }