@Override
public void sendRequest(final ClientRequest request, final ClientCallback<ClientExchange> clientCallback) {
    if(http2Delegate != null) {
        http2Delegate.sendRequest(request, clientCallback);
        return;
    }
    if (anyAreSet(state, UPGRADE_REQUESTED | UPGRADED | CLOSE_REQ | CLOSED)) {
        clientCallback.failed(UndertowClientMessages.MESSAGES.invalidConnectionState());
        return;
    }
    final HttpClientExchange httpClientExchange = new HttpClientExchange(clientCallback, request, this);
    boolean ssl = this.connection instanceof SslConnection;
    if(!ssl && !http2Tried && options.get(UndertowOptions.ENABLE_HTTP2, false) && !request.getRequestHeaders().contains(Headers.UPGRADE)) {
        //this is the first request, as we want to try a HTTP2 upgrade
        request.getRequestHeaders().put(new HttpString("HTTP2-Settings"), Http2ClearClientProvider.createSettingsFrame(options, bufferPool));
        request.getRequestHeaders().put(Headers.UPGRADE, Http2Channel.CLEARTEXT_UPGRADE_STRING);
        request.getRequestHeaders().put(Headers.CONNECTION, "Upgrade, HTTP2-Settings");
        http2Tried = true;
    }

    if (currentRequest == null) {
        initiateRequest(httpClientExchange);
    } else {
        pendingQueue.add(httpClientExchange);
    }
}
 

private void prepareResponseChannel(ClientResponse response, ClientExchange exchange) {
    String encoding = response.getResponseHeaders().getLast(Headers.TRANSFER_ENCODING);
    boolean chunked = encoding != null && Headers.CHUNKED.equals(new HttpString(encoding));
    String length = response.getResponseHeaders().getFirst(Headers.CONTENT_LENGTH);
    if (exchange.getRequest().getMethod().equals(Methods.HEAD)) {
        connection.getSourceChannel().setConduit(new FixedLengthStreamSourceConduit(connection.getSourceChannel().getConduit(), 0, responseFinishedListener));
    } else if (chunked) {
        connection.getSourceChannel().setConduit(new ChunkedStreamSourceConduit(connection.getSourceChannel().getConduit(), pushBackStreamSourceConduit, bufferPool, responseFinishedListener, exchange, connection));
    } else if (length != null) {
        try {
            long contentLength = Long.parseLong(length);
            connection.getSourceChannel().setConduit(new FixedLengthStreamSourceConduit(connection.getSourceChannel().getConduit(), contentLength, responseFinishedListener));
        } catch (NumberFormatException e) {
            handleError(e);
            throw e;
        }
    } else if (response.getProtocol().equals(Protocols.HTTP_1_1) && !Connectors.isEntityBodyAllowed(response.getResponseCode())) {
        connection.getSourceChannel().setConduit(new FixedLengthStreamSourceConduit(connection.getSourceChannel().getConduit(), 0, responseFinishedListener));
    } else {
        connection.getSourceChannel().setConduit(new FinishableStreamSourceConduit(connection.getSourceChannel().getConduit(), responseFinishedListener));
        state |= CLOSE_REQ;
    }
}
 

@Override
public void sendRequest(final ClientRequest request, final ClientCallback<ClientExchange> clientCallback) {
    if (anyAreSet(state, UPGRADE_REQUESTED | UPGRADED | CLOSE_REQ | CLOSED)) {
        clientCallback.failed(UndertowClientMessages.MESSAGES.invalidConnectionState());
        return;
    }
    final AjpClientExchange AjpClientExchange = new AjpClientExchange(clientCallback, request, this);
    if (currentRequest == null) {
        initiateRequest(AjpClientExchange);
    } else {
        pendingQueue.add(AjpClientExchange);
    }
}
 

AjpClientExchange(ClientCallback<ClientExchange> readyCallback, ClientRequest request, AjpClientConnection clientConnection) {
    this.readyCallback = readyCallback;
    this.request = request;
    this.clientConnection = clientConnection;
    boolean reqContinue = false;
    if (request.getRequestHeaders().contains(Headers.EXPECT)) {
        for (String header : request.getRequestHeaders().get(Headers.EXPECT)) {
            if (header.equals("100-continue")) {
                reqContinue = true;
            }
        }
    }
    this.requiresContinue = reqContinue;
}
 

@Override
public void setResponseListener(ClientCallback<ClientExchange> listener) {
    this.responseCallback = listener;
    if (listener != null) {
        if (failedReason != null) {
            listener.failed(failedReason);
        } else if (response != null) {
            listener.completed(this);
        }
    }
}
 

@Override
public void setResponseListener(ClientCallback<ClientExchange> responseListener) {
    this.responseListener = responseListener;
    if(failedReason != null) {
        responseListener.failed(failedReason);
    }
}
 

public Http2ClientConnection(Http2Channel http2Channel, ClientCallback<ClientExchange> upgradeReadyCallback, ClientRequest clientRequest, String defaultHost, ClientStatistics clientStatistics, boolean secure) {

        this.http2Channel = http2Channel;
        this.defaultHost = defaultHost;
        this.clientStatistics = clientStatistics;
        this.secure = secure;
        http2Channel.getReceiveSetter().set(new Http2ReceiveListener());
        http2Channel.resumeReceives();
        http2Channel.addCloseTask(closeTask);
        this.initialUpgradeRequest = false;

        Http2ClientExchange exchange = new Http2ClientExchange(this, null, clientRequest);
        exchange.setResponseListener(upgradeReadyCallback);
        currentExchanges.put(1, exchange);
    }
 

HttpClientExchange(ClientCallback<ClientExchange> readyCallback, ClientRequest request, HttpClientConnection clientConnection) {
    this.readyCallback = readyCallback;
    this.request = request;
    this.clientConnection = clientConnection;
    boolean reqContinue = false;
    if (request.getRequestHeaders().contains(Headers.EXPECT)) {
        for (String header : request.getRequestHeaders().get(Headers.EXPECT)) {
            if (header.equals("100-continue")) {
                reqContinue = true;
            }
        }
    }
    this.requiresContinue = reqContinue;
}
 

@Override
public void setResponseListener(ClientCallback<ClientExchange> listener) {
    this.responseCallback = listener;
    if (listener != null) {
        if (failedReason != null) {
            listener.failed(failedReason);
        } else if (response != null) {
            listener.completed(this);
        }
    }
}
 

private ResponseBodyListener(HttpServerExchange serverExchange, PooledConnection connection,
        ClientExchange clientExchange) {
    super(clientExchange.getConnection().getBufferPool());
    this.serverExchange = serverExchange;
    this.connection = connection;
    this.clientExchange = clientExchange;
}
 

void invokeReadReadyCallback(final ClientExchange result) {
    if(readyCallback != null) {
        readyCallback.completed(result);
        readyCallback = null;
    }
}
 

ClientCallback<ClientExchange> getResponseCallback() {
    return responseCallback;
}
 

@Override
public void completed(ClientExchange clientExchange) {
    clientExchange.setResponseListener(new ResponseListener(serverExchange, connection));
    writeBody(clientExchange);
}
 

@Override
public void completed(ClientExchange clientExchange) {
    StringReadChannelListener readChannelListener;
    readChannelListener = new ResponseBodyListener(serverExchange, connection, clientExchange);
    readChannelListener.setup(clientExchange.getResponseChannel());
}
 

private void sendRequest(ClientRequest request, ClientCallback<ClientExchange> clientCallback) {
    clientConnection.sendRequest(request, clientCallback);
}