Implement URLSession delegate for HTTPClient

Add followRedirects property to HTTPClientConfiguration

Author: mattt

Diff for: Sources/Basics/HTPClient+URLSession.swift

@@ -8,28 +8,120 @@ import struct TSCUtility.Versioning
 import FoundationNetworking
 #endif
 
-public struct URLSessionHTTPClient: HTTPClientProtocol {
-    private let configuration: URLSessionConfiguration
+public final class URLSessionHTTPClient: NSObject {
+    public var configuration: HTTPClientConfiguration = .init()
 
-    public init(configuration: URLSessionConfiguration = .default) {
-        self.configuration = configuration
+    private var session: URLSession!
+    private var taskDelegates: [URLSessionTask: TaskDelegate] = [:]
+
+    final class TaskDelegate: NSObject {
+        private let configuration: HTTPClientConfiguration
+        private let callback: (Result<HTTPClient.Response, Error>) -> Void
+        private var accumulatedData: Data = Data()
+
+        required init(configuration: HTTPClientConfiguration, callback: @escaping (Result<HTTPClient.Response, Error>) -> Void) {
+            self.configuration = configuration
+            self.callback = callback
+        }
     }
 
+    public required init(configuration: URLSessionConfiguration = .default) {
+        super.init()
+        self.session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+    }
+}
+
+extension URLSessionHTTPClient: HTTPClientProtocol {
     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))
+        let task = session.dataTask(with: request.urlRequest())
+        taskDelegates[task] = TaskDelegate(configuration: configuration, callback: callback)
+
+        task.resume()
+    }
+}
+
+extension URLSessionHTTPClient: URLSessionDataDelegate {
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           willPerformHTTPRedirection response: HTTPURLResponse,
+                           newRequest request: URLRequest,
+                           completionHandler: @escaping (URLRequest?) -> Void)
+    {
+        guard let delegate = taskDelegates[task] else {
+            return completionHandler(request)
+        }
+
+        delegate.urlSession(session, task: task, willPerformHTTPRedirection: response, newRequest: request, completionHandler: completionHandler)
+    }
+
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           didCompleteWithError error: Error?)
+    {
+        guard let delegate = taskDelegates[task] else { return }
+        defer { taskDelegates[task] = nil }
+
+        delegate.urlSession(session, task: task, didCompleteWithError: error)
+    }
+
+    public func urlSession(_ session: URLSession,
+                           dataTask: URLSessionDataTask,
+                           didReceive data: Data)
+    {
+        guard let delegate = taskDelegates[dataTask] else { return }
+        delegate.urlSession(session, dataTask: dataTask, didReceive: data)
+    }
+}
+
+
+extension URLSessionHTTPClient.TaskDelegate: URLSessionDataDelegate {
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           willPerformHTTPRedirection response: HTTPURLResponse,
+                           newRequest request: URLRequest,
+                           completionHandler: @escaping (URLRequest?) -> Void)
+    {
+        if configuration.followRedirects {
+            completionHandler(request)
+        } else {
+            completionHandler(nil)
+
+            configuration.callbackQueue.async {
+                self.callback(.success(response.response(body: nil)))
             }
         }
-        task.resume()
+    }
+
+    public func urlSession(_ session: URLSession,
+                           task: URLSessionTask,
+                           didCompleteWithError error: Error?)
+    {
+        if let error = error {
+            configuration.callbackQueue.async {
+                self.callback(.failure(error))
+            }
+        } else if let response = task.response as? HTTPURLResponse {
+            let body = accumulatedData.isEmpty ? nil : accumulatedData
+            configuration.callbackQueue.async {
+                self.callback(.success(response.response(body: body)))
+            }
+        } else {
+            configuration.callbackQueue.async {
+                self.callback(.failure(HTTPClientError.invalidResponse))
+            }
+        }
+    }
+
+    public func urlSession(_ session: URLSession,
+                           dataTask: URLSessionDataTask,
+                           didReceive data: Data)
+    {
+        accumulatedData.append(data)
     }
 }
 
+// MARK: -
+
 extension HTTPClient.Request {
     func urlRequest() -> URLRequest {
         var request = URLRequest(url: self.url)

Diff for: Sources/Basics/HTTPClient.swift

@@ -53,8 +53,14 @@ public struct HTTPClient: HTTPClientProtocol {
     public init(configuration: HTTPClientConfiguration = .init(), handler: Handler? = nil, diagnosticsEngine: DiagnosticsEngine? = nil) {
         self.configuration = configuration
         self.diagnosticsEngine = diagnosticsEngine
-        // FIXME: inject platform specific implementation here
-        self.underlying = handler ?? URLSessionHTTPClient().execute
+        if let handler = handler {
+            self.underlying = handler
+        } else {
+            // FIXME: inject platform-specific implementation here
+            let client = URLSessionHTTPClient()
+            client.configuration = configuration
+            self.underlying = client.execute
+        }
     }
 
     public func execute(_ request: Request, callback: @escaping (Result<Response, Error>) -> Void) {
@@ -207,13 +213,15 @@ public struct HTTPClientConfiguration {
     public var requestTimeout: DispatchTimeInterval?
     public var retryStrategy: HTTPClientRetryStrategy?
     public var circuitBreakerStrategy: HTTPClientCircuitBreakerStrategy?
+    public var followRedirects: Bool
     public var callbackQueue: DispatchQueue
 
     public init() {
         self.requestHeaders = .none
         self.requestTimeout = .none
         self.retryStrategy = .none
         self.circuitBreakerStrategy = .none
+        self.followRedirects = true
         self.callbackQueue = .global()
     }
 }