public Future connect()

in httpclient5/src/main/java/org/apache/hc/client5/http/impl/nio/DefaultAsyncClientConnectionOperator.java [94:181]
80 lines of code
12 McCabe index (conditional complexity)

    public Future<ManagedAsyncClientConnection> connect(
            final ConnectionInitiator connectionInitiator,
            final HttpHost endpointHost,
            final NamedEndpoint endpointName,
            final SocketAddress localAddress,
            final Timeout connectTimeout,
            final Object attachment,
            final HttpContext context,
            final FutureCallback<ManagedAsyncClientConnection> callback) {
        Args.notNull(connectionInitiator, "Connection initiator");
        Args.notNull(endpointHost, "Host");
        final ComplexFuture<ManagedAsyncClientConnection> future = new ComplexFuture<>(callback);
        final HttpHost remoteEndpoint = RoutingSupport.normalize(endpointHost, schemePortResolver);
        final InetAddress remoteAddress = endpointHost.getAddress();
        final TlsConfig tlsConfig = attachment instanceof TlsConfig ? (TlsConfig) attachment : TlsConfig.DEFAULT;

        onBeforeSocketConnect(context, endpointHost);
        if (LOG.isDebugEnabled()) {
            LOG.debug("{} connecting {}->{} ({})", endpointHost, localAddress, remoteAddress, connectTimeout);
        }

        final Future<IOSession> sessionFuture = sessionRequester.connect(
                connectionInitiator,
                remoteEndpoint,
                remoteAddress != null ? new InetSocketAddress(remoteAddress, remoteEndpoint.getPort()) : null,
                localAddress,
                connectTimeout,
                tlsConfig.getHttpVersionPolicy(),
                new FutureCallback<IOSession>() {

                    @Override
                    public void completed(final IOSession session) {
                        final DefaultManagedAsyncClientConnection connection = new DefaultManagedAsyncClientConnection(session);
                        onAfterSocketConnect(context, endpointHost);
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("{} {} connected {}->{}", ConnPoolSupport.getId(connection), endpointHost,
                                    connection.getLocalAddress(), connection.getRemoteAddress());
                        }
                        final TlsStrategy tlsStrategy = tlsStrategyLookup != null ? tlsStrategyLookup.lookup(endpointHost.getSchemeName()) : null;
                        if (tlsStrategy != null) {
                            try {
                                final Timeout socketTimeout = connection.getSocketTimeout();
                                final Timeout handshakeTimeout = tlsConfig.getHandshakeTimeout();
                                final NamedEndpoint tlsName = endpointName != null ? endpointName : endpointHost;
                                onBeforeTlsHandshake(context, endpointHost);
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("{} {} upgrading to TLS", ConnPoolSupport.getId(connection), tlsName);
                                }
                                tlsStrategy.upgrade(
                                        connection,
                                        tlsName,
                                        attachment,
                                        handshakeTimeout != null ? handshakeTimeout : connectTimeout,
                                        new FutureContribution<TransportSecurityLayer>(future) {

                                            @Override
                                            public void completed(final TransportSecurityLayer transportSecurityLayer) {
                                                connection.setSocketTimeout(socketTimeout);
                                                future.completed(connection);
                                                onAfterTlsHandshake(context, endpointHost);
                                                if (LOG.isDebugEnabled()) {
                                                    LOG.debug("{} {} upgraded to TLS", ConnPoolSupport.getId(connection), tlsName);
                                                }
                                            }

                                        });
                            } catch (final Exception ex) {
                                future.failed(ex);
                            }
                        } else {
                            future.completed(connection);
                        }
                    }

                    @Override
                    public void failed(final Exception ex) {
                        future.failed(ex);
                    }

                    @Override
                    public void cancelled() {
                        future.cancel();
                    }

                });
        future.setDependency(sessionFuture);
        return future;
    }