Refactored and consolidated existing socket path handling to prepare for the new schemes

Motivation:

Before I start adding support for new URL schemes, I consolitate the existing use of unix sockets and https TLS handling.

Modifications:

Consolidate socket path and uri handling to one place, added an associated type to the unixSocket case, and added a computed requiresTLS property to the Key Scheme.

Result:

Much cleaner code that is now ready for some new schemes!

Author: dimitribouniol

Sources/AsyncHTTPClient/ConnectionPool.swift

@@ -113,23 +113,32 @@ final class ConnectionPool {
                 self.scheme = .https
             case "unix":
                 self.scheme = .unix
-                self.unixPath = request.url.baseURL?.path ?? request.url.path
             default:
                 fatalError("HTTPClient.Request scheme should already be a valid one")
             }
             self.port = request.port
             self.host = request.host
+            self.unixPath = request.socketPath
         }
 
         var scheme: Scheme
         var host: String
         var port: Int
-        var unixPath: String = ""
+        var unixPath: String
 
         enum Scheme: Hashable {
             case http
             case https
             case unix
+            
+            var requiresTLS: Bool {
+                switch self {
+                case .https:
+                    return true
+                default:
+                    return false
+                }
+            }
         }
     }
 }
@@ -433,7 +442,7 @@ class HTTP1ConnectionProvider {
 
     private func makeChannel(preference: HTTPClient.EventLoopPreference) -> EventLoopFuture<Channel> {
         let eventLoop = preference.bestEventLoop ?? self.eventLoop
-        let requiresTLS = self.key.scheme == .https
+        let requiresTLS = self.key.scheme.requiresTLS
         let bootstrap: NIOClientTCPBootstrap
         do {
             bootstrap = try NIOClientTCPBootstrap.makeHTTPClientBootstrapBase(on: eventLoop, host: self.key.host, port: self.key.port, requiresTLS: requiresTLS, configuration: self.configuration)
@@ -451,7 +460,7 @@ class HTTP1ConnectionProvider {
         }
 
         return channel.flatMap { channel in
-            let requiresSSLHandler = self.configuration.proxy != nil && self.key.scheme == .https
+            let requiresSSLHandler = self.configuration.proxy != nil && self.key.scheme.requiresTLS
             let handshakePromise = channel.eventLoop.makePromise(of: Void.self)
 
             channel.pipeline.addSSLHandlerIfNeeded(for: self.key, tlsConfiguration: self.configuration.tlsConfiguration, addSSLClient: requiresSSLHandler, handshakePromise: handshakePromise)

Sources/AsyncHTTPClient/HTTPClient.swift

@@ -654,7 +654,7 @@ extension ChannelPipeline {
     }
 
     func addSSLHandlerIfNeeded(for key: ConnectionPool.Key, tlsConfiguration: TLSConfiguration?, addSSLClient: Bool, handshakePromise: EventLoopPromise<Void>) {
-        guard key.scheme == .https else {
+        guard key.scheme.requiresTLS else {
             handshakePromise.succeed(())
             return
         }

Sources/AsyncHTTPClient/HTTPHandler.swift

@@ -99,19 +99,26 @@ extension HTTPClient {
     public struct Request {
         /// Represent kind of Request
         enum Kind {
+            enum UnixScheme {
+                case baseURL
+            }
+            
             /// Remote host request.
             case host
             /// UNIX Domain Socket HTTP request.
-            case unixSocket
+            case unixSocket(_ scheme: UnixScheme)
 
             private static var hostSchemes = ["http", "https"]
             private static var unixSchemes = ["unix"]
 
             init(forScheme scheme: String) throws {
                 if Kind.host.supports(scheme: scheme) {
                     self = .host
-                } else if Kind.unixSocket.supports(scheme: scheme) {
-                    self = .unixSocket
+                } else if Kind.unixSchemes.contains(scheme) {
+                    switch scheme {
+                    case "unix": self = .unixSocket(.baseURL)
+                    default: preconditionFailure("scheme should already be a valid option")
+                    }
                 } else {
                     throw HTTPClientError.unsupportedScheme(scheme)
                 }
@@ -129,11 +136,35 @@ extension HTTPClient {
                 }
             }
 
+            func socketPathFromURL(_ url: URL) throws -> String {
+                switch self {
+                case .unixSocket(let scheme):
+                    switch scheme {
+                    case .baseURL:
+                        return url.baseURL?.path ?? url.path
+                    }
+                case .host:
+                    return ""
+                }
+            }
+            
+            func uriFromURL(_ url: URL) -> String {
+                switch self {
+                case .host:
+                    return url.uri
+                case .unixSocket(let scheme):
+                    switch scheme {
+                    case .baseURL:
+                        return url.baseURL != nil ? url.uri : "/"
+                    }
+                }
+            }
+
             func supports(scheme: String) -> Bool {
                 switch self {
                 case .host:
                     return Kind.hostSchemes.contains(scheme)
-                case .unixSocket:
+                case .unixSocket(scheme: _):
                     return Kind.unixSchemes.contains(scheme)
                 }
             }
@@ -147,6 +178,10 @@ extension HTTPClient {
         public let scheme: String
         /// Remote host, resolved from `URL`.
         public let host: String
+        /// Socket path, resolved from `URL`.
+        public let socketPath: String
+        /// URI, resolved from `URL`.
+        public let uri: String
         /// Request custom HTTP Headers, defaults to no headers.
         public var headers: HTTPHeaders
         /// Request body, defaults to no body.
@@ -199,6 +234,8 @@ extension HTTPClient {
 
             self.kind = try Kind(forScheme: scheme)
             self.host = try self.kind.hostFromURL(url)
+            self.socketPath = try self.kind.socketPathFromURL(url)
+            self.uri = self.kind.uriFromURL(url)
 
             self.redirectState = nil
             self.url = url
@@ -712,15 +749,7 @@ extension TaskHandler: ChannelDuplexHandler {
         self.state = .idle
         let request = self.unwrapOutboundIn(data)
 
-        let uri: String
-        switch (self.kind, request.url.baseURL) {
-        case (.host, _):
-            uri = request.url.uri
-        case (.unixSocket, .none):
-            uri = "/" // we don't have a real path, the path we have is the path of the UNIX Domain Socket.
-        case (.unixSocket, .some(_)):
-            uri = request.url.uri
-        }
+        let uri: String = request.uri
 
         var head = HTTPRequestHead(version: HTTPVersion(major: 1, minor: 1),
                                    method: request.method,