Example usage for io.vertx.core.http HttpClientResponse pause

Introduction

In this page you can find the example usage for io.vertx.core.http HttpClientResponse pause.

Prototype

@Override
    HttpClientResponse pause();

Source Link

Usage

From source file:io.apiman.gateway.platforms.vertx3.connector.HttpConnector.java

License:Apache License

private void doConnection() {
    String endpoint = ApimanPathUtils.join(apiPath, destination + queryParams(apiRequest.getQueryParams()));
    logger.debug(String.format("Connecting to %s | port: %d verb: %s path: %s", apiHost, apiPort,
            HttpMethod.valueOf(apiRequest.getType()), endpoint));

    clientRequest = client.request(HttpMethod.valueOf(apiRequest.getType()), apiPort, apiHost, endpoint,
            (HttpClientResponse vxClientResponse) -> {
                clientResponse = vxClientResponse;

                // Pause until we're given permission to xfer the response.
                vxClientResponse.pause();

                apiResponse = HttpApiFactory.buildResponse(vxClientResponse, SUPPRESSED_HEADERS);

                vxClientResponse.handler((Handler<Buffer>) chunk -> {
                    bodyHandler.handle(new VertxApimanBuffer(chunk));
                });/* w  ww  .j  a va  2s . com*/

                vxClientResponse.endHandler((Handler<Void>) v -> {
                    endHandler.handle((Void) null);
                });

                vxClientResponse.exceptionHandler(exceptionHandler);

                // The response is only ever returned when vxClientResponse is valid.
                resultHandler.handle(AsyncResultImpl.create((IApiConnectionResponse) HttpConnector.this));
            });

    clientRequest.exceptionHandler(exceptionHandler);

    if (options.hasDataPolicy()) {
        clientRequest.headers().remove("Content-Length");
        clientRequest.setChunked(true);
    }

    apiRequest.getHeaders().forEach(e -> clientRequest.headers().add(e.getKey(), e.getValue()));

    addMandatoryRequestHeaders(clientRequest.headers());

    if (options.getRequiredAuthType() == RequiredAuthType.BASIC) {
        clientRequest.putHeader("Authorization",
                Basic.encode(basicOptions.getUsername(), basicOptions.getPassword()));
    }
}

---

From source file:org.sfs.nodes.RemoteNode.java

License:Apache License

@Override
public Observable<NodeWriteStreamBlob> createWriteStream(final String volumeId, final long length,
        final MessageDigestFactory... messageDigestFactories) {
    final XNode _this = this;

    return Defer.aVoid().flatMap(aVoid -> nodes.connectFirstAvailable(vertx, hostAndPorts, hostAndPort -> {
        Escaper escaper = urlFragmentEscaper();

        StringBuilder urlBuilder = new StringBuilder("http://").append(hostAndPort.toString());
        urlBuilder = urlBuilder.append("/_internal_node_data/blob?");
        urlBuilder = urlBuilder.append(KEEP_ALIVE_TIMEOUT);
        urlBuilder = urlBuilder.append('=');
        urlBuilder = urlBuilder.append(responseTimeout / 2);
        urlBuilder = urlBuilder.append('&');
        urlBuilder = urlBuilder.append(VOLUME);
        urlBuilder = urlBuilder.append('=');
        urlBuilder = urlBuilder.append(escaper.escape(volumeId));

        if (messageDigestFactories.length > 0) {
            for (MessageDigestFactory instance : messageDigestFactories) {
                urlBuilder = urlBuilder.append('&');
                urlBuilder = urlBuilder/* w w  w. j  av  a2  s. c  o  m*/
                        .append(escaper
                                .escape(format("%s%s", X_CONTENT_COMPUTED_DIGEST_PREFIX, instance.getValue())))
                        .append('=').append("true");
            }
        }

        final String url = urlBuilder.toString();

        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("createWriteStream " + url);
        }

        ObservableFuture<HttpClientResponse> handler = RxHelper.observableFuture();

        HttpClientRequest httpClientRequest = httpClient.putAbs(url, httpClientResponse -> {
            httpClientResponse.pause();
            handler.complete(httpClientResponse);
        }).exceptionHandler(handler::fail).putHeader(X_SFS_REMOTE_NODE_TOKEN, remoteNodeSecret)
                .putHeader(CONTENT_LENGTH, valueOf(length)).setTimeout(responseTimeout);
        httpClientRequest.sendHead();

        return handler.map(
                httpClientResponse -> new HttpClientRequestAndResponse(httpClientRequest, httpClientResponse));
    })).map(httpClientRequestAndResponse -> {

        HttpClientRequest httpClientRequest = httpClientRequestAndResponse.getRequest();
        HttpClientResponse httpClientResponse = httpClientRequestAndResponse.getResponse();

        if (HTTP_OK != httpClientResponse.statusCode()) {
            httpClientResponse.resume();
            throw new HttpClientResponseException(httpClientResponse, Buffer.buffer());
        }
        Observable<DigestBlob> oResponse = Defer.just(httpClientResponse)
                .flatMap(new HttpClientKeepAliveResponseBodyBuffer()).map(new BufferToJsonObject())
                .map(jsonObject -> {
                    Integer code = jsonObject.getInteger("code");
                    if (code == null || HTTP_OK != code) {
                        throw new HttpClientResponseException(httpClientResponse, jsonObject);
                    }
                    return jsonObject;
                }).map(jsonObject -> {
                    JsonObject blob = jsonObject.getJsonObject("blob");
                    return new DigestBlob(blob);
                });

        NodeWriteStreamBlob writeStreamBlob = new NodeWriteStreamBlob(_this) {
            @Override
            public Observable<DigestBlob> consume(ReadStream<Buffer> src) {

                return combineSinglesDelayError(
                        pump(src, new HttpClientRequestEndableWriteStream(httpClientRequest)), oResponse,
                        (aVoid1, digestBlob) -> digestBlob);

            }
        };
        return writeStreamBlob;
    });
}

---