Added support for the new http+unix and https+unix schemes

Motivation:

We can now not only make connections over sockets using the existing unix: baseURL approach, but also by %-escaping the socket path as the URL's hostname, and using the http+unix: or https+unix: schemes for plain HTTP or HTTP over TLS support.

Modifications:

Added references to the new url schemes where necessary, aand added a missingSocketPath error for when the socket path is not encoded as the hostname.

Result:

The tests now pass, and connections can be made over non-special URLs, supporting TLS if necessary.

Author: dimitribouniol

Sources/AsyncHTTPClient/ConnectionPool.swift

@@ -113,6 +113,10 @@ final class ConnectionPool {
                 self.scheme = .https
             case "unix":
                 self.scheme = .unix
+            case "http+unix":
+                self.scheme = .http_unix
+            case "https+unix":
+                self.scheme = .https_unix
             default:
                 fatalError("HTTPClient.Request scheme should already be a valid one")
             }
@@ -130,10 +134,12 @@ final class ConnectionPool {
             case http
             case https
             case unix
+            case http_unix
+            case https_unix
 
             var requiresTLS: Bool {
                 switch self {
-                case .https:
+                case .https, .https_unix:
                     return true
                 default:
                     return false
@@ -455,7 +461,7 @@ class HTTP1ConnectionProvider {
         case .http, .https:
             let address = HTTPClient.resolveAddress(host: self.key.host, port: self.key.port, proxy: self.configuration.proxy)
             channel = bootstrap.connect(host: address.host, port: address.port)
-        case .unix:
+        case .unix, .http_unix, .https_unix:
             channel = bootstrap.connect(unixDomainSocketPath: self.key.unixPath)
         }
 

Sources/AsyncHTTPClient/HTTPClient.swift

@@ -726,6 +726,7 @@ public struct HTTPClientError: Error, Equatable, CustomStringConvertible {
     private enum Code: Equatable {
         case invalidURL
         case emptyHost
+        case missingSocketPath
         case alreadyShutdown
         case emptyScheme
         case unsupportedScheme(String)
@@ -758,6 +759,8 @@ public struct HTTPClientError: Error, Equatable, CustomStringConvertible {
     public static let invalidURL = HTTPClientError(code: .invalidURL)
     /// URL does not contain host.
     public static let emptyHost = HTTPClientError(code: .emptyHost)
+    /// URL does not contain a socketPath as a host for http(s)+unix shemes.
+    public static let missingSocketPath = HTTPClientError(code: .missingSocketPath)
     /// Client is shutdown and cannot be used for new requests.
     public static let alreadyShutdown = HTTPClientError(code: .alreadyShutdown)
     /// URL does not contain scheme.

Sources/AsyncHTTPClient/HTTPHandler.swift

@@ -101,6 +101,8 @@ extension HTTPClient {
         enum Kind {
             enum UnixScheme {
                 case baseURL
+                case http_unix
+                case https_unix
             }
 
             /// Remote host request.
@@ -109,14 +111,16 @@ extension HTTPClient {
             case unixSocket(_ scheme: UnixScheme)
 
             private static var hostSchemes = ["http", "https"]
-            private static var unixSchemes = ["unix"]
+            private static var unixSchemes = ["unix", "http+unix", "https+unix"]
 
             init(forScheme scheme: String) throws {
                 if Kind.host.supports(scheme: scheme) {
                     self = .host
                 } else if Kind.unixSchemes.contains(scheme) {
                     switch scheme {
                     case "unix": self = .unixSocket(.baseURL)
+                    case "http+unix": self = .unixSocket(.http_unix)
+                    case "https+unix": self = .unixSocket(.https_unix)
                     default: preconditionFailure("scheme should already be a valid option")
                     }
                 } else {
@@ -142,6 +146,11 @@ extension HTTPClient {
                     switch scheme {
                     case .baseURL:
                         return url.baseURL?.path ?? url.path
+                    case .http_unix, .https_unix:
+                        guard let socketPath = url.host else {
+                            throw HTTPClientError.missingSocketPath
+                        }
+                        return socketPath
                     }
                 case .host:
                     return ""
@@ -156,6 +165,8 @@ extension HTTPClient {
                     switch scheme {
                     case .baseURL:
                         return url.baseURL != nil ? url.uri : "/"
+                    case .http_unix, .https_unix:
+                        return url.uri
                     }
                 }
             }
@@ -227,6 +238,7 @@ extension HTTPClient {
         ///     - `emptyScheme` if URL does not contain HTTP scheme.
         ///     - `unsupportedScheme` if URL does contains unsupported HTTP scheme.
         ///     - `emptyHost` if URL does not contains a host.
+        ///     - `missingSocketPath` if URL does not contains a socketPath as an encoded host.
         public init(url: URL, method: HTTPMethod = .GET, headers: HTTPHeaders = HTTPHeaders(), body: Body? = nil) throws {
             guard let scheme = url.scheme?.lowercased() else {
                 throw HTTPClientError.emptyScheme
@@ -247,7 +259,7 @@ extension HTTPClient {
 
         /// Whether request will be executed using secure socket.
         public var useTLS: Bool {
-            return self.scheme == "https"
+            return self.scheme == "https" || self.scheme == "https+unix"
         }
 
         /// Resolved port.