add deadlines (#57)

Author: artemredkin

Sources/AsyncHTTPClient/HTTPClient.swift

@@ -58,64 +58,63 @@ public class HTTPClient {
         }
     }
 
-    public func get(url: String, timeout: Timeout? = nil) -> EventLoopFuture<Response> {
+    public func get(url: String, deadline: NIODeadline? = nil) -> EventLoopFuture<Response> {
         do {
             let request = try Request(url: url, method: .GET)
-            return self.execute(request: request, timeout: timeout)
+            return self.execute(request: request, deadline: deadline)
         } catch {
             return self.eventLoopGroup.next().makeFailedFuture(error)
         }
     }
 
-    public func post(url: String, body: Body? = nil, timeout: Timeout? = nil) -> EventLoopFuture<Response> {
+    public func post(url: String, body: Body? = nil, deadline: NIODeadline? = nil) -> EventLoopFuture<Response> {
         do {
             let request = try HTTPClient.Request(url: url, method: .POST, body: body)
-            return self.execute(request: request, timeout: timeout)
+            return self.execute(request: request, deadline: deadline)
         } catch {
             return self.eventLoopGroup.next().makeFailedFuture(error)
         }
     }
 
-    public func patch(url: String, body: Body? = nil, timeout: Timeout? = nil) -> EventLoopFuture<Response> {
+    public func patch(url: String, body: Body? = nil, deadline: NIODeadline? = nil) -> EventLoopFuture<Response> {
         do {
             let request = try HTTPClient.Request(url: url, method: .PATCH, body: body)
-            return self.execute(request: request, timeout: timeout)
+            return self.execute(request: request, deadline: deadline)
         } catch {
             return self.eventLoopGroup.next().makeFailedFuture(error)
         }
     }
 
-    public func put(url: String, body: Body? = nil, timeout: Timeout? = nil) -> EventLoopFuture<Response> {
+    public func put(url: String, body: Body? = nil, deadline: NIODeadline? = nil) -> EventLoopFuture<Response> {
         do {
             let request = try HTTPClient.Request(url: url, method: .PUT, body: body)
-            return self.execute(request: request, timeout: timeout)
+            return self.execute(request: request, deadline: deadline)
         } catch {
             return self.eventLoopGroup.next().makeFailedFuture(error)
         }
     }
 
-    public func delete(url: String, timeout: Timeout? = nil) -> EventLoopFuture<Response> {
+    public func delete(url: String, deadline: NIODeadline? = nil) -> EventLoopFuture<Response> {
         do {
             let request = try Request(url: url, method: .DELETE)
-            return self.execute(request: request, timeout: timeout)
+            return self.execute(request: request, deadline: deadline)
         } catch {
             return self.eventLoopGroup.next().makeFailedFuture(error)
         }
     }
 
-    public func execute(request: Request, timeout: Timeout? = nil) -> EventLoopFuture<Response> {
+    public func execute(request: Request, deadline: NIODeadline? = nil) -> EventLoopFuture<Response> {
         let accumulator = ResponseAccumulator(request: request)
-        return self.execute(request: request, delegate: accumulator, timeout: timeout).futureResult
+        return self.execute(request: request, delegate: accumulator, deadline: deadline).futureResult
     }
 
-    public func execute<T: HTTPClientResponseDelegate>(request: Request, delegate: T, timeout: Timeout? = nil) -> Task<T.Response> {
-        let timeout = timeout ?? configuration.timeout
+    public func execute<T: HTTPClientResponseDelegate>(request: Request, delegate: T, deadline: NIODeadline? = nil) -> Task<T.Response> {
         let eventLoop = self.eventLoopGroup.next()
 
         let redirectHandler: RedirectHandler<T.Response>?
         if self.configuration.followRedirects {
             redirectHandler = RedirectHandler<T.Response>(request: request) { newRequest in
-                self.execute(request: newRequest, delegate: delegate, timeout: timeout)
+                self.execute(request: newRequest, delegate: delegate, deadline: deadline)
             }
         } else {
             redirectHandler = nil
@@ -136,8 +135,8 @@ public class HTTPClient {
                         return channel.pipeline.addProxyHandler(for: request, decoder: decoder, encoder: encoder, tlsConfiguration: self.configuration.tlsConfiguration)
                     }
                 }.flatMap {
-                    if let readTimeout = timeout.read {
-                        return channel.pipeline.addHandler(IdleStateHandler(readTimeout: readTimeout))
+                    if let timeout = self.resolve(timeout: self.configuration.timeout.read, deadline: deadline) {
+                        return channel.pipeline.addHandler(IdleStateHandler(readTimeout: timeout))
                     } else {
                         return channel.eventLoop.makeSucceededFuture(())
                     }
@@ -147,8 +146,8 @@ public class HTTPClient {
                 }
             }
 
-        if let connectTimeout = timeout.connect {
-            bootstrap = bootstrap.connectTimeout(connectTimeout)
+        if let timeout = self.resolve(timeout: self.configuration.timeout.connect, deadline: deadline) {
+            bootstrap = bootstrap.connectTimeout(timeout)
         }
 
         let address = self.resolveAddress(request: request, proxy: self.configuration.proxy)
@@ -166,6 +165,19 @@ public class HTTPClient {
         return task
     }
 
+    private func resolve(timeout: TimeAmount?, deadline: NIODeadline?) -> TimeAmount? {
+        switch (timeout, deadline) {
+        case (.some(let timeout), .some(let deadline)):
+            return min(timeout, deadline - .now())
+        case (.some(let timeout), .none):
+            return timeout
+        case (.none, .some(let deadline)):
+            return deadline - .now()
+        case (.none, .none):
+            return nil
+        }
+    }
+
     private func resolveAddress(request: Request, proxy: Proxy?) -> (host: String, port: Int) {
         switch self.configuration.proxy {
         case .none:

Tests/AsyncHTTPClientTests/HTTPClientTests+XCTest.swift

@@ -38,6 +38,7 @@ extension HTTPClientTests {
             ("testStreaming", testStreaming),
             ("testRemoteClose", testRemoteClose),
             ("testReadTimeout", testReadTimeout),
+            ("testDeadline", testDeadline),
             ("testCancel", testCancel),
             ("testProxyPlaintext", testProxyPlaintext),
             ("testProxyTLS", testProxyTLS),

Tests/AsyncHTTPClientTests/HTTPClientTests.swift

@@ -236,6 +236,22 @@ class HTTPClientTests: XCTestCase {
         }
     }
 
+    func testDeadline() throws {
+        let httpBin = HttpBin()
+        let httpClient = HTTPClient(eventLoopGroupProvider: .createNew)
+
+        defer {
+            try! httpClient.syncShutdown()
+            httpBin.shutdown()
+        }
+
+        XCTAssertThrowsError(try httpClient.get(url: "http://localhost:\(httpBin.port)/wait", deadline: .now() + .milliseconds(150)).wait(), "Should fail") { error in
+            guard case let error = error as? HTTPClientError, error == .readTimeout else {
+                return XCTFail("Should fail with readTimeout")
+            }
+        }
+    }
+
     func testCancel() throws {
         let httpBin = HttpBin()
         let httpClient = HTTPClient(eventLoopGroupProvider: .createNew)