+//===----------------------------------------------------------------------===//+//+// 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 NIOHTTP1+import NIOSSL+import NIOTLS+#if canImport(Network)+    import NIOTransportServices+#endif++extension HTTPConnectionPool {+    enum NegotiatedProtocol {+        case http1_1(Channel)+        case http2_0(Channel)+    }++    final class ConnectionFactory {+        let key: ConnectionPool.Key+        let clientConfiguration: HTTPClient.Configuration+        let tlsConfiguration: TLSConfiguration+        let sslContextCache: SSLContextCache++        init(key: ConnectionPool.Key,+             tlsConfiguration: TLSConfiguration?,+             clientConfiguration: HTTPClient.Configuration,+             sslContextCache: SSLContextCache) {+            self.key = key+            self.clientConfiguration = clientConfiguration+            self.sslContextCache = sslContextCache+            self.tlsConfiguration = tlsConfiguration ?? clientConfiguration.tlsConfiguration ?? .forClient()+        }+    }+}++extension HTTPConnectionPool.ConnectionFactory {+    func makeBestChannel(connectionID: HTTPConnectionPool.Connection.ID, eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<(Channel, HTTPVersion)> {+        if self.key.scheme.isProxyable, let proxy = self.clientConfiguration.proxy {+            return self.makeHTTPProxyChannel(proxy, connectionID: connectionID, eventLoop: eventLoop, logger: logger)+        } else {+            return self.makeChannel(eventLoop: eventLoop, logger: logger)+        }+    }++    private func makeChannel(eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<(Channel, HTTPVersion)> {+        switch self.key.scheme {+        case .http, .http_unix, .unix:+            return self.makePlainChannel(eventLoop: eventLoop).map { ($0, .http1_1) }+        case .https, .https_unix:+            return self.makeTLSChannel(eventLoop: eventLoop, logger: logger).map {+                (channel, negotiated) -> (Channel, HTTPVersion) in+                let version = negotiated == "h2" ? HTTPVersion.http2 : HTTPVersion.http1_1+                return (channel, version)+            }+        }+    }++    private func makePlainChannel(eventLoop: EventLoop) -> EventLoopFuture<Channel> {+        let bootstrap = self.makePlainBootstrap(eventLoop: eventLoop)++        switch self.key.scheme {+        case .http:+            return bootstrap.connect(host: self.key.host, port: self.key.port)+        case .http_unix, .unix:+            return bootstrap.connect(unixDomainSocketPath: self.key.unixPath)+        case .https, .https_unix:+            preconditionFailure("Unexpected schema")+        }+    }++    private func makeHTTPProxyChannel(+        _ proxy: HTTPClient.Configuration.Proxy,+        connectionID: HTTPConnectionPool.Connection.ID,+        eventLoop: EventLoop,+        logger: Logger+    ) -> EventLoopFuture<(Channel, HTTPVersion)> {+        // A proxy connection starts with a plain text connection to the proxy server. After+        // the connection has been established with the proxy server, the connection might be+        // upgraded to TLS before we send our first request.+        let bootstrap = self.makePlainBootstrap(eventLoop: eventLoop)+        return bootstrap.connect(host: proxy.host, port: proxy.port).flatMap { channel in+            let connectPromise = channel.eventLoop.makePromise(of: Void.self)++            let encoder = HTTPRequestEncoder()+            let decoder = ByteToMessageHandler(HTTPResponseDecoder(leftOverBytesStrategy: .dropBytes))+            let proxyHandler = HTTP1ProxyConnectHandler(+                targetHost: self.key.host,+                targetPort: self.key.port,+                proxyAuthorization: proxy.authorization,+                connectPromise: connectPromise+            )++            do {+                try channel.pipeline.syncOperations.addHandler(encoder)+                try channel.pipeline.syncOperations.addHandler(decoder)+                try channel.pipeline.syncOperations.addHandler(proxyHandler)+            } catch {+                return channel.eventLoop.makeFailedFuture(error)+            }++            return connectPromise.futureResult.flatMap {+                channel.pipeline.removeHandler(proxyHandler).flatMap {+                    channel.pipeline.removeHandler(decoder).flatMap {+                        channel.pipeline.removeHandler(encoder)+                    }+                }+            }.flatMap { () -> EventLoopFuture<(Channel, HTTPVersion)> in+                switch self.key.scheme {+                case .unix, .http_unix, .https_unix:+                    preconditionFailure("Unexpected scheme. Not supported for proxy!")+                case .http:+                    return channel.eventLoop.makeSucceededFuture((channel, .http1_1))+                case .https:+                    var tlsConfig = self.tlsConfiguration+                    // since we can support h2, we need to advertise this in alpn+                    tlsConfig.applicationProtocols = ["http/1.1" /* , "h2" */ ]+                    let tlsEventHandler = TLSEventsHandler()++                    let sslContextFuture = self.sslContextCache.sslContext(+                        tlsConfiguration: tlsConfig,+                        eventLoop: channel.eventLoop,+                        logger: logger+                    )++                    return sslContextFuture.flatMap { sslContext -> EventLoopFuture<String?> in+                        do {+                            let sslHandler = try NIOSSLClientHandler(+                                context: sslContext,+                                serverHostname: self.key.host+                            )+                            try channel.pipeline.syncOperations.addHandler(sslHandler)+                            try channel.pipeline.syncOperations.addHandler(tlsEventHandler)+                            return tlsEventHandler.tlsEstablishedFuture+                        } catch {+                            return channel.eventLoop.makeFailedFuture(error)+                        }+                    }.flatMap { negotiated -> EventLoopFuture<(Channel, HTTPVersion)> in+                        channel.pipeline.removeHandler(tlsEventHandler).map {+                            switch negotiated {+                            case "h2":+                                return (channel, .http2)+                            default:+                                return (channel, .http1_1)+                            }+                        }+                    }+                }+            }+        }+    }++    private func makePlainBootstrap(eventLoop: EventLoop) -> NIOClientTCPBootstrapProtocol {+        #if canImport(Network)+            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), let tsBootstrap = NIOTSConnectionBootstrap(validatingGroup: eventLoop) {+                return tsBootstrap+                    .addTimeoutIfNeeded(self.clientConfiguration.timeout)+                    .channelInitializer { channel in+                        do {+                            try channel.pipeline.syncOperations.addHandler(HTTPClient.NWErrorHandler())

+//===----------------------------------------------------------------------===//+//+// 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 NIO+import NIOHTTP1++final class HTTP1ProxyConnectHandler: ChannelDuplexHandler, RemovableChannelHandler {+    typealias OutboundIn = Never+    typealias OutboundOut = HTTPClientRequestPart+    typealias InboundIn = HTTPClientResponsePart++    enum State {+        case initialized(EventLoopPromise<Void>)+        case connectSent(EventLoopPromise<Void>)+        case headReceived(EventLoopPromise<Void>)+        case failed(Error)+        case completed+    }++    private var state: State++    let targetHost: String+    let targetPort: Int+    let proxyAuthorization: HTTPClient.Authorization?++    init(targetHost: String,+         targetPort: Int,+         proxyAuthorization: HTTPClient.Authorization?,+         connectPromise: EventLoopPromise<Void>) {+        self.targetHost = targetHost+        self.targetPort = targetPort+        self.proxyAuthorization = proxyAuthorization++        self.state = .initialized(connectPromise)+    }++    func handlerAdded(context: ChannelHandlerContext) {+        precondition(context.channel.isActive, "Expected to be added to an active channel")++        self.sendConnect(context: context)+    }++    func handlerRemoved(context: ChannelHandlerContext) {+        switch self.state {+        case .failed, .completed:+            break+        case .initialized, .connectSent, .headReceived:+            preconditionFailure("Removing the handler, while connecting seems wrong")+        }+    }++    func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {+        preconditionFailure("We don't support outgoing traffic during HTTP Proxy update.")

+//===----------------------------------------------------------------------===//+//+// 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 NIOConcurrencyHelpers++extension HTTPConnectionPool.Connection.ID {+    static var globalGenerator = Generator()++    struct Generator {+        private let atomic: NIOAtomic<Int>

+//===----------------------------------------------------------------------===//+//+// 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 NIOHTTP1+import NIOSSL+import NIOTLS+#if canImport(Network)+    import NIOTransportServices+#endif++extension HTTPConnectionPool {+    enum NegotiatedProtocol {+        case http1_1(Channel)+        case http2_0(Channel)+    }++    final class ConnectionFactory {+        let key: ConnectionPool.Key+        let clientConfiguration: HTTPClient.Configuration+        let tlsConfiguration: TLSConfiguration+        let sslContextCache: SSLContextCache++        init(key: ConnectionPool.Key,+             tlsConfiguration: TLSConfiguration?,+             clientConfiguration: HTTPClient.Configuration,+             sslContextCache: SSLContextCache) {+            self.key = key+            self.clientConfiguration = clientConfiguration+            self.sslContextCache = sslContextCache+            self.tlsConfiguration = tlsConfiguration ?? clientConfiguration.tlsConfiguration ?? .forClient()+        }+    }+}++extension HTTPConnectionPool.ConnectionFactory {+    func makeBestChannel(connectionID: HTTPConnectionPool.Connection.ID, eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<(Channel, HTTPVersion)> {+        if self.key.scheme.isProxyable, let proxy = self.clientConfiguration.proxy {+            return self.makeHTTPProxyChannel(proxy, connectionID: connectionID, eventLoop: eventLoop, logger: logger)+        } else {+            return self.makeChannel(eventLoop: eventLoop, logger: logger)+        }+    }++    private func makeChannel(eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<(Channel, HTTPVersion)> {+        switch self.key.scheme {+        case .http, .http_unix, .unix:+            return self.makePlainChannel(eventLoop: eventLoop).map { ($0, .http1_1) }+        case .https, .https_unix:+            return self.makeTLSChannel(eventLoop: eventLoop, logger: logger).map {+                (channel, negotiated) -> (Channel, HTTPVersion) in+                let version = negotiated == "h2" ? HTTPVersion.http2 : HTTPVersion.http1_1+                return (channel, version)+            }+        }+    }++    private func makePlainChannel(eventLoop: EventLoop) -> EventLoopFuture<Channel> {+        let bootstrap = self.makePlainBootstrap(eventLoop: eventLoop)++        switch self.key.scheme {+        case .http:+            return bootstrap.connect(host: self.key.host, port: self.key.port)+        case .http_unix, .unix:+            return bootstrap.connect(unixDomainSocketPath: self.key.unixPath)+        case .https, .https_unix:+            preconditionFailure("Unexpected schema")+        }+    }++    private func makeHTTPProxyChannel(+        _ proxy: HTTPClient.Configuration.Proxy,+        connectionID: HTTPConnectionPool.Connection.ID,+        eventLoop: EventLoop,+        logger: Logger+    ) -> EventLoopFuture<(Channel, HTTPVersion)> {+        // A proxy connection starts with a plain text connection to the proxy server. After+        // the connection has been established with the proxy server, the connection might be+        // upgraded to TLS before we send our first request.+        let bootstrap = self.makePlainBootstrap(eventLoop: eventLoop)+        return bootstrap.connect(host: proxy.host, port: proxy.port).flatMap { channel in+            let connectPromise = channel.eventLoop.makePromise(of: Void.self)++            let encoder = HTTPRequestEncoder()+            let decoder = ByteToMessageHandler(HTTPResponseDecoder(leftOverBytesStrategy: .dropBytes))+            let proxyHandler = HTTP1ProxyConnectHandler(+                targetHost: self.key.host,+                targetPort: self.key.port,+                proxyAuthorization: proxy.authorization,+                connectPromise: connectPromise+            )++            do {+                try channel.pipeline.syncOperations.addHandler(encoder)+                try channel.pipeline.syncOperations.addHandler(decoder)+                try channel.pipeline.syncOperations.addHandler(proxyHandler)+            } catch {+                return channel.eventLoop.makeFailedFuture(error)+            }++            return connectPromise.futureResult.flatMap {+                channel.pipeline.removeHandler(proxyHandler).flatMap {+                    channel.pipeline.removeHandler(decoder).flatMap {+                        channel.pipeline.removeHandler(encoder)+                    }+                }+            }.flatMap { () -> EventLoopFuture<(Channel, HTTPVersion)> in+                switch self.key.scheme {+                case .unix, .http_unix, .https_unix:+                    preconditionFailure("Unexpected scheme. Not supported for proxy!")+                case .http:+                    return channel.eventLoop.makeSucceededFuture((channel, .http1_1))+                case .https:+                    var tlsConfig = self.tlsConfiguration+                    // since we can support h2, we need to advertise this in alpn+                    tlsConfig.applicationProtocols = ["http/1.1" /* , "h2" */ ]+                    let tlsEventHandler = TLSEventsHandler()++                    let sslContextFuture = self.sslContextCache.sslContext(+                        tlsConfiguration: tlsConfig,+                        eventLoop: channel.eventLoop,+                        logger: logger+                    )++                    return sslContextFuture.flatMap { sslContext -> EventLoopFuture<String?> in+                        do {+                            let sslHandler = try NIOSSLClientHandler(+                                context: sslContext,+                                serverHostname: self.key.host+                            )+                            try channel.pipeline.syncOperations.addHandler(sslHandler)+                            try channel.pipeline.syncOperations.addHandler(tlsEventHandler)+                            return tlsEventHandler.tlsEstablishedFuture+                        } catch {+                            return channel.eventLoop.makeFailedFuture(error)+                        }+                    }.flatMap { negotiated -> EventLoopFuture<(Channel, HTTPVersion)> in+                        channel.pipeline.removeHandler(tlsEventHandler).map {+                            switch negotiated {+                            case "h2":+                                return (channel, .http2)+                            default:+                                return (channel, .http1_1)+                            }+                        }+                    }+                }+            }+        }+    }++    private func makePlainBootstrap(eventLoop: EventLoop) -> NIOClientTCPBootstrapProtocol {+        #if canImport(Network)+            if #available(OSX 10.14, iOS 12.0, tvOS 12.0, watchOS 6.0, *), let tsBootstrap = NIOTSConnectionBootstrap(validatingGroup: eventLoop) {+                return tsBootstrap+                    .addTimeoutIfNeeded(self.clientConfiguration.timeout)+                    .channelInitializer { channel in+                        do {+                            try channel.pipeline.syncOperations.addHandler(HTTPClient.NWErrorHandler())

+//===----------------------------------------------------------------------===//+//+// 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 NIOHTTP1+import NIOSSL+import NIOTLS+#if canImport(Network)+    import NIOTransportServices+#endif++extension HTTPConnectionPool {+    enum NegotiatedProtocol {+        case http1_1(Channel)+        case http2_0(Channel)+    }++    final class ConnectionFactory {+        let key: ConnectionPool.Key+        let clientConfiguration: HTTPClient.Configuration+        let tlsConfiguration: TLSConfiguration+        let sslContextCache: SSLContextCache++        init(key: ConnectionPool.Key,+             tlsConfiguration: TLSConfiguration?,+             clientConfiguration: HTTPClient.Configuration,+             sslContextCache: SSLContextCache) {+            self.key = key+            self.clientConfiguration = clientConfiguration+            self.sslContextCache = sslContextCache+            self.tlsConfiguration = tlsConfiguration ?? clientConfiguration.tlsConfiguration ?? .forClient()+        }+    }+}++extension HTTPConnectionPool.ConnectionFactory {+    func makeBestChannel(connectionID: HTTPConnectionPool.Connection.ID, eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<(Channel, HTTPVersion)> {+        if self.key.scheme.isProxyable, let proxy = self.clientConfiguration.proxy {+            return self.makeHTTPProxyChannel(proxy, connectionID: connectionID, eventLoop: eventLoop, logger: logger)+        } else {+            return self.makeChannel(eventLoop: eventLoop, logger: logger)+        }+    }++    private func makeChannel(eventLoop: EventLoop, logger: Logger) -> EventLoopFuture<(Channel, HTTPVersion)> {+        switch self.key.scheme {+        case .http, .http_unix, .unix:+            return self.makePlainChannel(eventLoop: eventLoop).map { ($0, .http1_1) }+        case .https, .https_unix:+            return self.makeTLSChannel(eventLoop: eventLoop, logger: logger).map {+                (channel, negotiated) -> (Channel, HTTPVersion) in+                let version = negotiated == "h2" ? HTTPVersion.http2 : HTTPVersion.http1_1+                return (channel, version)+            }+        }+    }++    private func makePlainChannel(eventLoop: EventLoop) -> EventLoopFuture<Channel> {+        let bootstrap = self.makePlainBootstrap(eventLoop: eventLoop)++        switch self.key.scheme {+        case .http:+            return bootstrap.connect(host: self.key.host, port: self.key.port)+        case .http_unix, .unix:+            return bootstrap.connect(unixDomainSocketPath: self.key.unixPath)+        case .https, .https_unix:+            preconditionFailure("Unexpected schema")+        }+    }++    private func makeHTTPProxyChannel(+        _ proxy: HTTPClient.Configuration.Proxy,+        connectionID: HTTPConnectionPool.Connection.ID,+        eventLoop: EventLoop,+        logger: Logger+    ) -> EventLoopFuture<(Channel, HTTPVersion)> {+        // A proxy connection starts with a plain text connection to the proxy server. After+        // the connection has been established with the proxy server, the connection might be+        // upgraded to TLS before we send our first request.+        let bootstrap = self.makePlainBootstrap(eventLoop: eventLoop)+        return bootstrap.connect(host: proxy.host, port: proxy.port).flatMap { channel in+            let connectPromise = channel.eventLoop.makePromise(of: Void.self)++            let encoder = HTTPRequestEncoder()+            let decoder = ByteToMessageHandler(HTTPResponseDecoder(leftOverBytesStrategy: .dropBytes))+            let proxyHandler = HTTP1ProxyConnectHandler(+                targetHost: self.key.host,+                targetPort: self.key.port,+                proxyAuthorization: proxy.authorization,+                connectPromise: connectPromise+            )++            do {+                try channel.pipeline.syncOperations.addHandler(encoder)

+//===----------------------------------------------------------------------===//+//+// 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 NIO+import NIOHTTP1++final class HTTP1ProxyConnectHandler: ChannelDuplexHandler, RemovableChannelHandler {+    typealias OutboundIn = Never+    typealias OutboundOut = HTTPClientRequestPart+    typealias InboundIn = HTTPClientResponsePart++    enum State {+        case initialized(EventLoopPromise<Void>)+        case connectSent(EventLoopPromise<Void>)+        case headReceived(EventLoopPromise<Void>)+        case failed(Error)+        case completed+    }++    private var state: State++    let targetHost: String+    let targetPort: Int+    let proxyAuthorization: HTTPClient.Authorization?++    init(targetHost: String,+         targetPort: Int,+         proxyAuthorization: HTTPClient.Authorization?,+         connectPromise: EventLoopPromise<Void>) {+        self.targetHost = targetHost+        self.targetPort = targetPort+        self.proxyAuthorization = proxyAuthorization++        self.state = .initialized(connectPromise)+    }++    func handlerAdded(context: ChannelHandlerContext) {+        precondition(context.channel.isActive, "Expected to be added to an active channel")++        self.sendConnect(context: context)+    }++    func handlerRemoved(context: ChannelHandlerContext) {+        switch self.state {+        case .failed, .completed:+            break+        case .initialized, .connectSent, .headReceived:+            preconditionFailure("Removing the handler, while connecting seems wrong")+        }+    }++    func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {+        preconditionFailure("We don't support outgoing traffic during HTTP Proxy update.")