Use Request.Kind to distinguish between host and unix socket kind of http request.

Author: krzyzanowskim

Diff for: Sources/AsyncHTTPClient/HTTPClient.swift

@@ -282,7 +282,7 @@ public class HTTPClient {
         }
 
         let eventLoopChannel: EventLoopFuture<Channel>
-        if request.scheme == "unix", let baseURL = request.url.baseURL {
+        if request.kind == .unixSocket, let baseURL = request.url.baseURL {
             eventLoopChannel = bootstrap.connect(unixDomainSocketPath: baseURL.path)
         } else {
             let address = self.resolveAddress(request: request, proxy: self.configuration.proxy)

Diff for: Sources/AsyncHTTPClient/HTTPHandler.swift

@@ -88,48 +88,44 @@ extension HTTPClient {
 
     /// Represent HTTP request.
     public struct Request {
-        /// Request HTTP method, defaults to `GET`.
-        public var method: HTTPMethod {
-            return value.method
+
+        /// Represent kind of Request
+        enum Kind {
+            /// Remote host request.
+            case host
+            /// UNIX Domain Socket HTTP request.
+            case unixSocket
+
+            func isSchemeSupported(scheme: String) -> Bool {
+                switch self {
+                case .host:
+                    return scheme == "http" || scheme == "https"
+                case .unixSocket:
+                    return scheme == "unix"
+                }
+            }
         }
+
+        /// Request HTTP method, defaults to `GET`.
+        public var method: HTTPMethod
         /// Remote URL.
-        public var url: URL {
-            return value.url
-        }
+        public var url: URL
         /// Remote HTTP scheme, resolved from `URL`.
-        public var scheme: String {
-            return value.scheme
-        }
+        public var scheme: String
         /// Remote host, resolved from `URL`.
-        public var host: String {
-            return value.host
-        }
+        public var host: String
         /// Request custom HTTP Headers, defaults to no headers.
-        public var headers: HTTPHeaders {
-            get {
-                return value.headers
-            }
-            set {
-                value.headers = newValue
-            }
-        }
+        public var headers: HTTPHeaders
         /// Request body, defaults to no body.
-        public var body: Body? {
-            get {
-                return value.body
-            }
-            set {
-                value.body = newValue
-            }
-        }
+        public var body: Body?
 
         struct RedirectState {
             var count: Int
             var visited: Set<URL>?
         }
 
         var redirectState: RedirectState?
-        private var value: HTTPRequest
+        let kind: Kind
 
         /// Create HTTP request.
         ///
@@ -156,58 +152,6 @@ extension HTTPClient {
         ///
         /// - parameters:
         ///     - url: Remote `URL`.
-        ///     - version: HTTP version.
-        ///     - method: HTTP method.
-        ///     - headers: Custom HTTP headers.
-        ///     - body: Request body.
-        /// - throws:
-        ///     - `emptyScheme` if URL does not contain HTTP scheme.
-        ///     - `unsupportedScheme` if URL does contains unsupported HTTP scheme.
-        ///     - `emptyHost` if URL does not contains a host.
-        public init(url: URL, method: HTTPMethod = .GET, headers: HTTPHeaders = HTTPHeaders(), body: Body? = nil) throws {
-          if url.scheme?.lowercased() == "unix" {
-                self.value = try UnixDomainRequest(url: url, method: method, headers: headers, body: body)
-            } else {
-                self.value = try HostRequest(url: url, method: method, headers: headers, body: body)
-            }
-            self.redirectState = nil
-        }
-
-        /// Whether request will be executed using secure socket.
-        public var useTLS: Bool {
-            return self.scheme == "https"
-        }
-
-        /// Resolved port.
-        public var port: Int {
-            return self.url.port ?? (self.useTLS ? 443 : 80)
-        }
-
-        func isSchemeSupported(scheme: String) -> Bool {
-            return type(of: self.value).isSchemeSupported(scheme: scheme)
-        }
-    }
-
-    /// Represent HTTP request.
-    public struct HostRequest: HTTPRequest {
-        /// Request HTTP method, defaults to `GET`.
-        public let method: HTTPMethod
-        /// Remote URL.
-        public let url: URL
-        /// Remote HTTP scheme, resolved from `URL`.
-        public let scheme: String
-        /// Remote host, resolved from `URL`.
-        public let host: String
-        /// Request custom HTTP Headers, defaults to no headers.
-        public var headers: HTTPHeaders
-        /// Request body, defaults to no body.
-        public var body: Body?
-
-        /// Create an HTTP `Request`.
-        ///
-        /// - parameters:
-        ///     - url: Remote `URL`.
-        ///     - version: HTTP version.
         ///     - method: HTTP method.
         ///     - headers: Custom HTTP headers.
         ///     - body: Request body.
@@ -220,75 +164,41 @@ extension HTTPClient {
                 throw HTTPClientError.emptyScheme
             }
 
-            guard Self.isSchemeSupported(scheme: scheme) else {
-                throw HTTPClientError.unsupportedScheme(scheme)
-            }
+            if Kind.host.isSchemeSupported(scheme: scheme) {
+                self.kind = .host
+                guard let host = url.host else {
+                    throw HTTPClientError.emptyHost
+                }
 
-            guard let host = url.host else {
-                throw HTTPClientError.emptyHost
+                self.host = host
+            } else if Kind.unixSocket.isSchemeSupported(scheme: scheme) {
+                self.kind = .unixSocket
+                self.host = ""
+            } else {
+                throw HTTPClientError.unsupportedScheme(scheme)
             }
 
-            self.method = method
+            self.redirectState = nil
             self.url = url
+            self.method = method
             self.scheme = scheme
-            self.host = host
             self.headers = headers
             self.body = body
         }
 
-        static func isSchemeSupported(scheme: String) -> Bool {
-            return scheme == "http" || scheme == "https"
+        /// Whether request will be executed using secure socket.
+        public var useTLS: Bool {
+            return self.scheme == "https"
         }
-    }
-
-    /// Represent UNIX Domain Socket HTTP request.
-    public struct UnixDomainRequest: HTTPRequest {
-        /// Request HTTP method, defaults to `GET`.
-        public let method: HTTPMethod
-        /// UNIX Domain Socket file URL.
-        public let url: URL
-        /// Remote HTTP scheme, resolved from `URL`. Unused.
-        public let scheme: String
-        /// Remote host, resolved from `URL`. Unused.
-        public let host: String
-        /// Request custom HTTP Headers, defaults to no headers.
-        public var headers: HTTPHeaders
-        /// Request body, defaults to no body.
-        public var body: Body?
-
-        /// Create an HTTP `Request`.
-        ///
-        /// - parameters:
-        ///     - url: UNIX Domain Socket `URL`.
-        ///     - version: HTTP version.
-        ///     - method: HTTP method.
-        ///     - headers: Custom HTTP headers.
-        ///     - body: Request body.
-        /// - throws:
-        ///     - `emptyScheme` if URL does not contain HTTP scheme.
-        ///     - `unsupportedScheme` if URL does contains unsupported HTTP scheme.
-        ///     - `emptyHost` if URL does not contains a 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
-            }
 
-            guard scheme == "unix" else {
-                throw HTTPClientError.invalidURL
-            }
-
-            self.method = method
-            self.url = url
-            self.scheme = scheme
-            self.host = ""
-            self.headers = headers
-            self.body = body
+        /// Resolved port.
+        public var port: Int {
+            return self.url.port ?? (self.useTLS ? 443 : 80)
         }
 
-        static func isSchemeSupported(scheme: String) -> Bool {
-            return scheme == "unix"
+        func isSchemeSupported(scheme: String) -> Bool {
+            return kind.isSchemeSupported(scheme: scheme)
         }
-
     }
 
     /// Represent HTTP response.