Add HTTPClientTask

Author: fabianfett

Diff for: Sources/AsyncHTTPClient/ConnectionPool/HTTPClientTask.swift

@@ -0,0 +1,136 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the AsyncHTTPClient open source project
+//
+// Copyright (c) 2021 Apple Inc. and the AsyncHTTPClient project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of AsyncHTTPClient project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import Logging
+import NIO
+import NIOConcurrencyHelpers
+import NIOHTTP1
+
+/// A handle to the request queuer.
+///
+/// Use this handle to cancel the request, while it is waiting for a free connection, to execute the request.
+/// This protocol is implemented by the `HTTPConnectionPool`.
+protocol HTTPTaskQueuer {
+    /// Informs the task queuer that a request has been cancelled.
+    func cancelRequest(task: HTTPClientTask)
+}
+
+/// A handle to the request executor.
+///
+/// This protocol is implemented by the `HTTP1ClientChannelHandler`.
+protocol HTTPTaskExecutor {
+    /// Writes a body part into the channel pipeline
+    ///
+    /// This method may be **called on any thread**. The executor needs to ensure thread safety.
+    func writeRequestBodyPart(_: IOData, task: HTTPClientTask)
+
+    /// Signals that the request body stream has finished
+    ///
+    /// This method may be **called on any thread**. The executor needs to ensure thread safety.
+    func finishRequestBodyStream(task: HTTPClientTask)
+
+    /// Signals that more bytes from response body stream can be consumed.
+    ///
+    /// The request executor will call `receiveResponseBodyPart(_ buffer: ByteBuffer)` with more data after
+    /// this call.
+    ///
+    /// This method may be **called on any thread**. The executor needs to ensure thread safety.
+    func demandResponseBodyStream(task: HTTPClientTask)
+
+    /// Signals that the request has been cancelled.
+    ///
+    /// This method may be **called on any thread**. The executor needs to ensure thread safety.
+    func cancelRequest(task: HTTPClientTask)
+}
+
+/// An abstraction over a request that we want to send. A request may need to comunicate with its request
+/// queuer and executor. The client's methods will be called synchronously on an `EventLoop` by the
+/// executor. For this reason it is very important that the implementation of these functions never blocks.
+protocol HTTPClientTask: AnyObject {
+    /// The task's logger
+    var logger: Logger { get }
+
+    /// A connection to run this task on needs to be found before this deadline!
+    var connectionDeadline: NIODeadline? { get }
+
+    /// The request's head.
+    ///
+    /// Based on the content of the request head the task executor will call `startRequestBodyStream`
+    /// after `requestHeadSent` was called.
+    var requestHead: HTTPRequestHead { get }
+
+    /// The maximal `TimeAmount` that is allowed to pass between reads from the Channel.
+    var idleReadTimeout: TimeAmount? { get }
+
+    /// The task's eventLoopPreference
+    var eventLoopPreference: HTTPClient.EventLoopPreference { get }
+
+    /// Informs the task, that it was queued for execution
+    ///
+    /// This happens if all available connections are currently in use
+    func requestWasQueued(_: HTTPTaskQueuer)
+
+    /// Informs the task about the connection it will be executed on
+    ///
+    /// This is only here to allow existing tests to pass. We should rework this ASAP to get rid of this functionality
+    func willBeExecutedOnConnection(_: HTTPConnectionPool.Connection)
+
+    /// Will be called by the ChannelHandler to indicate that the request is going to be send.
+    ///
+    /// This will be called on the Channel's EventLoop. Do **not block** during your execution!
+    ///
+    /// - Returns: A bool indicating if the request should really be started. Return false if the request has already been cancelled.
+    ///            If the request is cancelled after this method call `executor.cancel()` to stop request execution.
+    func willExecuteRequest(_: HTTPTaskExecutor) -> Bool
+
+    /// Will be called by the ChannelHandler to indicate that the request head has been sent.
+    ///
+    /// This will be called on the Channel's EventLoop. Do **not block** during your execution!
+    func requestHeadSent(_: HTTPRequestHead)
+
+    /// Start request streaming
+    ///
+    /// This will be called on the Channel's EventLoop. Do **not block** during your execution!
+    func startRequestBodyStream()
+
+    /// Pause request streaming
+    ///
+    /// This will be called on the Channel's EventLoop. Do **not block** during your execution!
+    func pauseRequestBodyStream()
+
+    /// Resume request streaming
+    ///
+    /// This will be called on the Channel's EventLoop. Do **not block** during your execution!
+    func resumeRequestBodyStream()
+
+    /// Receive a response head.
+    ///
+    /// Please note that `receiveResponseHead` and `receiveResponseBodyPart` may
+    /// be called in quick succession. It is the task's job to buffer those events for the user. Once all
+    /// buffered data has been consumed the task must call `executor.demandResponseBodyStream`
+    /// to ask for more data.
+    func receiveResponseHead(_ head: HTTPResponseHead)
+
+    /// Receive a response body stream part.
+    ///
+    /// Please note that `receiveResponseHead` and `receiveResponseBodyPart` may
+    /// be called in quick succession. It is the task's job to buffer those events for the user. Once all
+    /// buffered data has been consumed the task must call `executor.demandResponseBodyStream`
+    /// to ask for more data.
+    func receiveResponseBodyPart(_ buffer: ByteBuffer)
+
+    func receiveResponseEnd()
+
+    func fail(_ error: Error)
+}

Diff for: Sources/AsyncHTTPClient/HTTPHandler.swift

@@ -624,6 +624,10 @@ extension URL {
     }
 }
 
+protocol HTTPClientTaskDelegate {
+    func cancel()
+}
+
 extension HTTPClient {
     /// Response execution context. Will be created by the library and could be used for obtaining
     /// `EventLoopFuture<Response>` of the execution or cancellation of the execution.