HTTP Client abstraction (#3040)

motivation: incoming features use HTTP to access remote resources: package collection and package registry. we should abstract given complexy around error handling and non-apple platform support

changes:
* create HTTPClient utility in Basics modules
* implement URLSession based backend
* implment exponential backoff
* implement (naive) circuit breaker
* add tests

Next Steps:
* discuss our approach to non-apple platforms (given FoundationNetworking dependency on OpenSSL)

Author: tomerd

Package.swift

@@ -208,6 +208,9 @@ let package = Package(
 
         // MARK: SwiftPM tests
 
+        .testTarget(
+            name: "BasicsTests",
+            dependencies: ["Basics", "SPMTestSupport"]),
         .testTarget(
             name: "BuildTests",
             dependencies: ["Build", "SPMTestSupport"]),

Sources/Basics/CMakeLists.txt

@@ -7,7 +7,10 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 add_library(Basics
-  FileSystem+Extensions.swift)
+  DispatchTimeInterval+Extensions.swift
+  FileSystem+Extensions.swift
+  HTPClient+URLSession.swift
+  HTTPClient.swift)
 target_link_libraries(Basics PUBLIC
   TSCBasic
   TSCUtility)

Sources/Basics/DispatchTimeInterval+Extensions.swift

@@ -0,0 +1,59 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2020 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+import Dispatch
+import struct Foundation.TimeInterval
+
+extension DispatchTimeInterval {
+    func timeInterval() -> TimeInterval? {
+        switch self {
+        case .seconds(let value):
+            return Double(value)
+        case .milliseconds(let value):
+            return Double(value) / 1000
+        case .microseconds(let value):
+            return Double(value) / 1_000_000
+        case .nanoseconds(let value):
+            return Double(value) / 1_000_000_000
+        default:
+            return nil
+        }
+    }
+
+    func milliseconds() -> Int? {
+        switch self {
+        case .seconds(let value):
+            return value.multipliedReportingOverflow(by: 1000).partialValue
+        case .milliseconds(let value):
+            return value
+        case .microseconds(let value):
+            return Int(Double(value) / 1000)
+        case .nanoseconds(let value):
+            return Int(Double(value) / 1_000_000)
+        default:
+            return nil
+        }
+    }
+
+    func seconds() -> Int? {
+        switch self {
+        case .seconds(let value):
+            return value
+        case .milliseconds(let value):
+            return Int(Double(value) / 1000)
+        case .microseconds(let value):
+            return Int(Double(value) / 1_000_000)
+        case .nanoseconds(let value):
+            return Int(Double(value) / 1_000_000_000)
+        default:
+            return nil
+        }
+    }
+}

Sources/Basics/FileSystem+Extensions.swift

@@ -18,7 +18,7 @@ extension FileSystem {
 }
 
 extension FileSystem {
-    /// SwiftPM cache directory under usre's caches directory (if exists)
+    /// SwiftPM cache directory under user's caches directory (if exists)
     public var swiftPMCacheDirectory: AbsolutePath {
         if let cachesDirectory = self.cachesDirectory {
             return cachesDirectory.appending(component: "org.swift.swiftpm")

Sources/Basics/HTPClient+URLSession.swift

@@ -0,0 +1,73 @@
+
+
+import Foundation
+import struct TSCUtility.Versioning
+#if canImport(FoundationNetworking)
+// FIXME: this brings OpenSSL dependency on Linux
+// need to decide how to best deal with that
+import FoundationNetworking
+#endif
+
+public struct URLSessionHTTPClient {
+    private let configuration: URLSessionConfiguration
+
+    public init(configuration: URLSessionConfiguration) {
+        self.configuration = configuration
+    }
+
+    public func execute(request: HTTPClient.Request, callback: @escaping (Result<HTTPClient.Response, Error>) -> Void) {
+        let session = URLSession(configuration: self.configuration)
+        let task = session.dataTask(with: request.urlRequest()) { data, response, error in
+            if let error = error {
+                callback(.failure(error))
+            } else if let response = response as? HTTPURLResponse {
+                callback(.success(response.response(body: data)))
+            } else {
+                callback(.failure(HTTPClientError.invalidResponse))
+            }
+        }
+        task.resume()
+    }
+}
+
+extension HTTPClient.Request {
+    func urlRequest() -> URLRequest {
+        var request = URLRequest(url: self.url)
+        request.httpMethod = self.methodString()
+        self.headers.forEach { header in
+            request.addValue(header.value, forHTTPHeaderField: header.name)
+        }
+        request.httpBody = self.body
+        if let interval = self.options.timeout?.timeInterval() {
+            request.timeoutInterval = interval
+        }
+        return request
+    }
+
+    func methodString() -> String {
+        switch self.method {
+        case .head:
+            return "HEAD"
+        case .get:
+            return "GET"
+        case .post:
+            return "POST"
+        case .put:
+            return "PUT"
+        case .delete:
+            return "DELETE"
+        }
+    }
+}
+
+extension HTTPURLResponse {
+    func response(body: Data?) -> HTTPClient.Response {
+        let headers = HTTPClientHeaders(self.allHeaderFields.map { header in
+            .init(name: "\(header.key)", value: "\(header.value)")
+        })
+        return HTTPClient.Response(statusCode: self.statusCode,
+                                   statusText: Self.localizedString(forStatusCode: self.statusCode),
+                                   headers: headers,
+                                   body: body)
+    }
+}