Example usage for io.vertx.core.http HttpClientRequest setChunked

List of usage examples for io.vertx.core.http HttpClientRequest setChunked

  1. HOME
  2. Java
  3. io.vertx
  4. io.vertx.core.http.*
  5. HttpClientRequest
  6. setChunked

Introduction

In this page you can find the example usage for io.vertx.core.http HttpClientRequest setChunked.

Prototype

@Fluent
HttpClientRequest setChunked(boolean chunked);

Source Link

Document

If chunked is true then the request will be set into HTTP chunked mode

Usage

From source file:examples.HTTPExamples.java

License:Open Source License

public void example41(HttpClientRequest request) {

    request.setChunked(true);

    // Write some chunks
    for (int i = 0; i < 10; i++) {
        request.write("this-is-chunk-" + i);
    }/*from   www  .j av  a  2  s.com*/

    request.end();
}

From source file:examples.HTTPExamples.java

License:Open Source License

public void example44(HttpClientRequest request, AsyncFile file) {

    request.setChunked(true);
    Pump pump = Pump.pump(file, request);
    file.endHandler(v -> request.end());
    pump.start();// w w  w  .  jav a  2 s  . com

}

From source file:io.apiman.gateway.platforms.vertx3.components.HttpClientComponentImpl.java

License:Apache License

@Override
public IHttpClientRequest request(String endpoint, HttpMethod method,
        IAsyncResultHandler<IHttpClientResponse> responseHandler) {

    URL pEndpoint = parseEndpoint(endpoint);
    int port = pEndpoint.getPort();
    String proto = pEndpoint.getProtocol();
    HttpClient client;/*from w  w w  .j a va2  s .  c o  m*/

    // If protocol provided
    if (port != -1 || proto != null) {
        if (port == 443 || "https".equals(proto)) { //$NON-NLS-1$
            client = sslClient;
            port = (port == -1) ? 443 : port;
        } else {
            client = plainClient;
            port = (port == -1) ? 80 : port;
        }
    } else {
        client = plainClient;
        port = 80;
    }

    HttpClientRequest request = client.request(convertMethod(method), pEndpoint.getPort(), pEndpoint.getHost(),
            pEndpoint.getFile(), new HttpClientResponseImpl(responseHandler));

    request.setChunked(true);

    request.exceptionHandler(exception -> {
        logger.error("Exception in HttpClientRequestImpl: {0}", exception.getMessage()); //$NON-NLS-1$
        responseHandler.handle(AsyncResultImpl.create(exception));
    });

    return new HttpClientRequestImpl(request);
}

From source file:io.gravitee.gateway.http.vertx.VertxHttpClient.java

License:Apache License

@Override
public ClientRequest request(io.gravitee.common.http.HttpMethod method, URI uri, HttpHeaders headers,
        Handler<ClientResponse> responseHandler) {
    HttpClient httpClient = httpClients.computeIfAbsent(Vertx.currentContext(), createHttpClient());

    final int port = uri.getPort() != -1 ? uri.getPort() : (HTTPS_SCHEME.equals(uri.getScheme()) ? 443 : 80);

    String relativeUri = (uri.getRawQuery() == null) ? uri.getRawPath()
            : uri.getRawPath() + '?' + uri.getRawQuery();

    HttpClientRequest clientRequest = httpClient.request(convert(method), port, uri.getHost(), relativeUri,
            clientResponse -> handleClientResponse(clientResponse, responseHandler));

    clientRequest.setTimeout(endpoint.getHttpClientOptions().getReadTimeout());

    VertxClientRequest invokerRequest = new VertxClientRequest(clientRequest);

    clientRequest.exceptionHandler(event -> {
        LOGGER.error("Server proxying failed: {}", event.getMessage());

        if (invokerRequest.connectTimeoutHandler() != null && event instanceof ConnectTimeoutException) {
            invokerRequest.connectTimeoutHandler().handle(event);
        } else {/*from  w  w w.j a  v a 2 s  .co  m*/
            VertxClientResponse clientResponse = new VertxClientResponse(
                    ((event instanceof ConnectTimeoutException) || (event instanceof TimeoutException))
                            ? HttpStatusCode.GATEWAY_TIMEOUT_504
                            : HttpStatusCode.BAD_GATEWAY_502);

            clientResponse.headers().set(HttpHeaders.CONNECTION, HttpHeadersValues.CONNECTION_CLOSE);

            Buffer buffer = null;

            if (event.getMessage() != null) {
                // Create body content with error message
                buffer = Buffer.buffer(event.getMessage());
                clientResponse.headers().set(HttpHeaders.CONTENT_LENGTH, Integer.toString(buffer.length()));
            }

            responseHandler.handle(clientResponse);

            if (buffer != null) {
                clientResponse.bodyHandler().handle(buffer);
            }

            clientResponse.endHandler().handle(null);
        }
    });

    // Copy headers to final API
    copyRequestHeaders(headers, clientRequest,
            (port == 80 || port == 443) ? uri.getHost() : uri.getHost() + ':' + port);

    // Check chunk flag on the request if there are some content to push and if transfer_encoding is set
    // with chunk value
    if (hasContent(headers)) {
        String transferEncoding = headers.getFirst(HttpHeaders.TRANSFER_ENCODING);
        if (HttpHeadersValues.TRANSFER_ENCODING_CHUNKED.equalsIgnoreCase(transferEncoding)) {
            clientRequest.setChunked(true);
        }
    }

    // Send HTTP head as soon as possible
    clientRequest.sendHead();

    return invokerRequest;
}

From source file:io.helixservice.feature.restclient.RestRequest.java

License:Open Source License

/**
 * Execute the request, with the expected response body marshaled
 * to a specific object type.//from www  .  ja v a2  s.c o m
 *
 * @param responseType Type we expect the response to be marshaled to
 * @return RestResponse fluent interface
 * @throws SuspendExecution For Vert.x Sync
 */
public <T> RestResponse<T> asObject(Class<T> responseType) throws SuspendExecution {
    try {
        // Apply Params & Url Vars
        String modifiedUrlPath = addParameters(replaceUrlVars(urlPath));

        // Do request
        HttpClientRequest request;
        if (useDefaultHostAndPort) {
            request = httpClient.get().request(io.vertx.core.http.HttpMethod.valueOf(method.name()),
                    modifiedUrlPath);
        } else {
            request = httpClient.get().requestAbs(io.vertx.core.http.HttpMethod.valueOf(method.name()),
                    modifiedUrlPath);
        }

        // Set timeout, if requested
        if (timeoutInMs != null) {
            request.setTimeout(timeoutInMs);
        }

        // With headers
        request.headers().addAll(VertxTypeConverter.toVertxMultiMap(headers));

        // Write body if we need to
        Buffer body = Buffer.buffer();
        if (requestBody.isPresent()) {
            request.setChunked(true);
            Message message = marshallerSupplier.get().marshal(requestBody);

            List<String> contentTypes = message.getContentTypes();
            if (contentTypes != null && contentTypes.size() > 0) {
                request.putHeader("Content-Type", contentTypes);
            }

            body = body.appendBytes(message.getBody());
        }

        // Wait for response with Vert.x Sync
        HttpClientResponse httpClientResponse = getHttpClientResponse(request, body);
        Buffer bodyBuffer = getBuffer(httpClientResponse);

        return new RestResponse<>(httpClientResponse, bodyBuffer, marshallerSupplier, responseType);
    } catch (URISyntaxException | UnsupportedEncodingException e) {
        throw new IllegalArgumentException("Unable to parse urlPath=" + urlPath, e);
    }
}

From source file:io.nitor.api.backend.msgraph.GraphQueryHandler.java

License:Apache License

@Override
public void handle(RoutingContext ctx) {
    HttpServerRequest sreq = ctx.request();
    String path = sreq.path();//w w w.  j  a v  a  2 s  . com
    path = path.substring(routeLength);
    if (!path.startsWith("/")) {
        path = '/' + path;
    }
    path = baseUrl + path + paramsOf(ctx.request().absoluteURI());

    Map<String, String> data = sessionHandler.getSessionData(ctx);
    String refreshToken = data.get(GRAPH_ACCESS_TOKEN_KEY);
    Future<TokenData> tokenFuture = tokenCache.getAccessToken(refreshToken);

    HttpServerResponse sres = ctx.response();
    String finalPath = path;
    tokenFuture.setHandler(tokenResult -> {
        if (tokenResult.failed()) {
            sessionHandler.removeCookie(ctx);
            String err = tokenResult.cause().toString();
            logger.error(err);
            sres.setStatusCode(INTERNAL_SERVER_ERROR.code()).end(err);
            return;
        }
        TokenData token = tokenResult.result();
        if (!refreshToken.equals(token.refreshToken)) {
            Map<String, String> newData = new HashMap<>(data);
            newData.put(GRAPH_ACCESS_TOKEN_KEY, token.refreshToken);
            sessionHandler.setSessionData(ctx, newData);
        }
        String clientRequestId = UUID.randomUUID().toString();
        logger.info("Querying " + sreq.method() + " " + finalPath + " [" + clientRequestId + "]");
        HttpClientRequest creq = httpClient.requestAbs(sreq.method(), finalPath)
                .putHeader(AUTHORIZATION, "Bearer " + token.accessToken).putHeader(ACCEPT, APPLICATION_JSON)
                .putHeader("client-request-id", clientRequestId).setTimeout(SECONDS.toMillis(20))
                .exceptionHandler(err -> {
                    logger.error("Graph query failed [" + clientRequestId + "]", err);
                    if (!sres.ended()) {
                        sres.setStatusCode(INTERNAL_SERVER_ERROR.code()).write("Graph query failed: " + err)
                                .end();
                    }
                });

        for (String header : allowedRequestHeaders) {
            ofNullable(sreq.getHeader(header)).ifPresent(value -> creq.putHeader(header, value));
        }
        if (sres.headers().getAll("transfer-encoding").stream().anyMatch(v -> v.equals("chunked"))) {
            creq.setChunked(true);
        }

        sres.closeHandler(close -> creq.connection().close());
        creq.handler(cres -> mapResponse(cres, sres, clientRequestId));

        if (sreq.isEnded()) {
            creq.end();
        } else {
            sreq.endHandler(v -> {
                try {
                    creq.end();
                } catch (IllegalStateException ex) {
                    // ignore - nothing can be done - the request is already complete/closed - TODO log?
                }
            });
            Pump resPump = Pump.pump(sreq, creq);
            resPump.start();
        }
    });
}

From source file:io.nitor.api.backend.proxy.Proxy.java

License:Apache License

public void handle(RoutingContext routingContext) {
    final HttpServerRequest sreq = routingContext.request();
    final boolean isTls = isOrigReqHttps || "https".equals(routingContext.request().scheme());
    final boolean isHTTP2 = routingContext.request().version() == HTTP_2;
    final String chost = getRemoteAddress(routingContext);
    final ProxyTracer tracer = tracerFactory.get();
    String reqId = sreq.headers().get(requestIdHeader);
    boolean hadRequestId = reqId != null;
    if (reqId == null) {
        reqId = Long.toString(requestId.getAndIncrement());
    }/*w w  w .  ja  v a 2 s. co m*/
    tracer.incomingRequestStart(routingContext, isTls, isHTTP2, chost, reqId);
    if (!hadRequestId) {
        sreq.headers().add(requestIdHeader, reqId);
    }

    HttpServerResponse sres = sreq.response();
    sres.exceptionHandler(tracer::outgoingResponseException);
    routingContext.addHeadersEndHandler(tracer::outgoingResponseHeadersEnd);
    sres.bodyEndHandler(tracer::outgoingResponseBodyEnd);
    if (!isHTTP2) {
        sres.headers().add("keep-alive", keepAliveHeaderValue);
        sres.headers().add("connection", "keep-alive");
    }
    sreq.exceptionHandler(t -> {
        tracer.incomingRequestException(t);
        routingContext.fail(new ProxyException(500, RejectReason.incomingRequestFail, t));
    });

    final State state = new State();

    targetResolver.resolveNextHop(routingContext, nextHop -> {
        if (nextHop == null) {
            NullPointerException e = new NullPointerException("nextHop must not be null");
            tracer.incomingRequestException(e);
            throw e;
        }
        tracer.nextHopResolved(nextHop);

        MultiMap sreqh = sreq.headers();
        String origHost = null;
        if (isHTTP2) {
            origHost = sreqh.get(":authority");
        }
        if (origHost == null) {
            origHost = sreqh.get("Host");
        }
        if (origHost == null) {
            ProxyException e = new ProxyException(400, RejectReason.noHostHeader, null);
            tracer.incomingRequestException(e);
            routingContext.fail(e);
            return;
        }
        boolean isWebsocket = !isHTTP2 && "websocket".equals(sreqh.get("upgrade"));
        if (isWebsocket) {
            MultiMap creqh = new CaseInsensitiveHeaders();
            propagateRequestHeaders(isTls, chost, sreqh, origHost, creqh);
            if (nextHop.hostHeader != null) {
                creqh.set("Host", nextHop.hostHeader);
            } else {
                creqh.remove("Host");
            }
            tracer.outgoingWebsocketInitial(creqh);
            client.websocket(nextHop.socketPort, nextHop.socketHost, nextHop.uri, creqh, cws -> {
                // lol no headers copied
                final boolean[] isClosed = { false };
                ServerWebSocket sws = sreq.upgrade();
                tracer.websocketEstablished();
                for (final WebSocketBase[] pair : new WebSocketBase[][] { { sws, cws }, { cws, sws } }) {
                    pair[0].frameHandler(pair[1]::writeFrame).closeHandler(v -> {
                        if (!isClosed[0]) {
                            tracer.establishedWebsocketClosed();
                            isClosed[0] = true;
                            pair[1].close();
                        }
                    }).exceptionHandler(t -> {
                        tracer.establishedWebsocketException(t);
                        t.printStackTrace();
                        if (!isClosed[0]) {
                            isClosed[0] = true;
                            try {
                                pair[1].close();
                            } catch (IllegalStateException e) {
                                // whatever
                            }
                        }
                    });
                }
            }, t -> {
                tracer.outgoingWebsocketException(t);
                t.printStackTrace();
                sres.setStatusCode(HttpResponseStatus.BAD_GATEWAY.code());
                if (t instanceof WebSocketHandshakeRejectedException) {
                    WebSocketHandshakeRejectedException e = (WebSocketHandshakeRejectedException) t;
                    sres.setStatusCode(e.resp.status().code());
                    sres.setStatusMessage(e.resp.status().reasonPhrase());
                    MultiMap cresh = new HeadersAdaptor(e.resp.headers());
                    copyEndToEndHeaders(cresh, sres.headers());
                    sres.headers().add("keep-alive", keepAliveHeaderValue);
                    sres.headers().add("connection", "keep-alive");
                    sres.headers().set("content-length", "0");
                }
                tracer.outgoingResponseInitial();
                tracer.outgoingResponseHeadersEnd(null);
                sres.end();
                tracer.outgoingResponseBodyEnd(null);
            });
            return;
        }
        String expectStr;
        state.expecting100 = null != (expectStr = sreq.headers().get("expect"))
                && expectStr.equalsIgnoreCase("100-continue");
        HttpClientRequest creq = client.request(sreq.method(), nextHop.socketPort, nextHop.socketHost,
                nextHop.uri);
        creq.setTimeout(SECONDS.toMillis(clientReceiveTimeout));
        creq.handler(cres -> {
            cres.exceptionHandler(t -> {
                tracer.incomingResponseException(t);
                if (!state.serverFinished) {
                    state.clientFinished = true;
                    state.serverFinished = true;
                    routingContext.fail(new ProxyException(502, RejectReason.incomingResponseFail, t));
                }
            });
            tracer.incomingResponseStart(cres);
            sres.setStatusCode(cres.statusCode());
            sres.setStatusMessage(cres.statusMessage());
            MultiMap headers = cres.headers();
            copyEndToEndHeaders(headers, sres.headers());
            final boolean reqCompletedBeforeResponse = state.requestComplete;
            if (state.expecting100) {
                log.info("Got " + cres.statusCode() + " instead of 100 Continue");
                if (!isHTTP2) {
                    if (/* state.receivedRequestBodyBefore100 && */ !reqCompletedBeforeResponse) {
                        // TODO investigate whether vertx is able to handle the server request correctly without us closing the conn
                        // but actually the client might have data in transit..
                        log.info(
                                "Client might have started streaming data anyway, so request message boundary is lost. Continue streaming, but close server connection after response complete.");
                        sres.headers().set("connection", "close");
                    } else {
                        log.info(
                                "Client had streamed the complete data anyway. Can carry on without closing server conn.");
                    }
                }
            }
            if (!isHTTP2) {
                if (!sres.headers().contains("connection")
                        || !sres.headers().get("connection").contains("close")) {
                    sres.headers().add("keep-alive", keepAliveHeaderValue);
                    sres.headers().add("connection", "keep-alive");
                }
            }
            if (!headers.contains("content-length")) {
                sres.setChunked(true);
            }
            tracer.outgoingResponseInitial();
            cres.endHandler(v -> {
                tracer.incomingResponseEnd();
                state.clientFinished = true;
                if (!state.serverFinished) {
                    state.serverFinished = true;
                    sres.end();
                }
                if (state.expecting100
                        && /* state.receivedRequestBodyBefore100 && */ !reqCompletedBeforeResponse) {
                    log.info(
                            "Client had started streaming data anyway, so request message boundary is lost. Close client connection.");
                    creq.connection().close();
                }
            });
            pump.start(cres, sres, tracer);
        });
        creq.exceptionHandler(t -> {
            tracer.outgoingRequestException(t);
            if (!state.serverFinished) {
                state.clientFinished = true;
                state.serverFinished = true;
                routingContext.fail(new ProxyException(502, RejectReason.outgoingRequestFail, t));
            }
        });
        MultiMap creqh = creq.headers();
        propagateRequestHeaders(isTls, chost, sreqh, origHost, creqh);
        creq.headers().addAll(addHeaders);
        if (nextHop.hostHeader != null) {
            creq.setHost(nextHop.hostHeader);
        } else {
            creqh.remove("host");
        }
        if (sreqh.getAll("transfer-encoding").stream().anyMatch(v -> v.equals("chunked"))) {
            creq.setChunked(true);
        }
        sres.closeHandler(v -> {
            if (!state.clientFinished) {
                state.clientFinished = true;
                tracer.incomingConnectionPrematurelyClosed();
                HttpConnection connection = creq.connection();
                if (connection != null) {
                    connection.close();
                } // else TODO
            }
            if (!state.serverFinished) {
                state.serverFinished = true;
                routingContext.fail(new ProxyException(0, RejectReason.outgoingResponseFail, null));
            }
        });
        tracer.outgoingRequestInitial(creq);
        if (sreq.isEnded()) {
            state.requestComplete = true;
            Buffer body = routingContext.getBody();
            if (body == null || body.length() == 0) {
                creq.end();
            } else {
                if (!creq.isChunked()) {
                    creq.putHeader("content-length", Integer.toString(body.length()));
                }
                creq.end(routingContext.getBody());
            }
            tracer.incomingRequestEnd();
        } else {
            sreq.endHandler(v -> {
                state.requestComplete = true;
                try {
                    creq.end();
                } catch (IllegalStateException ex) {
                    // ignore - nothing can be done - the request is already complete/closed - TODO log?
                }
                tracer.incomingRequestEnd();
            });

            ReadStream<Buffer> sreqStream;
            if (state.expecting100) {
                log.debug("Expect: 100");
                creq.continueHandler(v -> {
                    // no longer expecting 100, it's like a normal not-expecting-100 request from now on
                    state.expecting100 = false;
                    // since we received 100 Continue, we know the server agrees to accept all the request body, so we can assume we are forgiven for sending data early
                    state.receivedRequestBodyBefore100 = false;
                    log.info("Got 100, propagating");
                    sres.writeContinue();
                });
                // in this case we must flush request headers before the body is sent
                creq.sendHead();
                sreqStream = new ReadStreamWrapper<Buffer>(sreq) {
                    final LazyHandlerWrapper<Buffer> handlerWrapper = new LazyHandlerWrapper<Buffer>(
                            super::handler, null) {
                        @Override
                        public void handle(Buffer event) {
                            log.info("Got first request body chunk");
                            if (state.expecting100) {
                                log.info("Got request body before '100 Continue'");
                                // data received despite not having yet recived 100-continue
                                state.receivedRequestBodyBefore100 = true;
                            }
                            deactivate();
                            wrapped.handle(event);
                        }
                    };

                    @Override
                    public ReadStream<Buffer> handler(Handler<Buffer> handler) {
                        return handlerWrapper.handler(handler, this);
                    }
                };
            } else {
                log.debug("Not expect-100");
                sreqStream = sreq;
            }
            pump.start(sreqStream, creq, tracer);
        }
    });
}

From source file:io.ventu.rpc.rest.HttpRestInvokerImpl.java

License:MIT License

@Override
public <RQ, RS> CompletableFuture<RS> invoke(final RQ request, final Class<RS> responseClass) {
    final CompletableFuture<RS> answer = new CompletableFuture<>();
    try {//from  w  w w .j  a  v a2  s . c o m
        String url = requestRouter.route(request);

        HttpMethod method = HttpMethod.POST;
        switch (requestRouter.type(request)) {
        case GET:
            method = HttpMethod.GET;
            break;
        case PUT:
            method = HttpMethod.PUT;
            break;
        case DELETE:
            method = HttpMethod.DELETE;
            break;
        default: // POST, keep as is
        }

        HttpClientRequest httpRequest = client.request(method, url, httpResponse -> {
            int statusCode = httpResponse.statusCode();
            if (statusCode < 400) {
                httpResponse.bodyHandler(buffer -> {
                    try {
                        RS resp = serializer.decode(buffer.getBytes(), responseClass);
                        responseValidator.validate(resp);
                        answer.complete(resp);
                    } catch (ApiException | EncodingException | IllegalArgumentException
                            | NullPointerException ex) {
                        answer.completeExceptionally(ex);
                    }
                });
            } else {
                answer.completeExceptionally(new HttpException(statusCode, httpResponse.statusMessage()));
            }
        });
        for (Entry<String, String> entry : headers.entrySet()) {
            httpRequest.putHeader(entry.getKey(), entry.getValue());
        }
        httpRequest.putHeader("Content-type", CONTENT_TYPE).putHeader("Accept", CONTENT_TYPE);

        if ((method == HttpMethod.POST) || (method == HttpMethod.PUT)) {
            byte[] payload = serializer.encode(request);
            httpRequest.setChunked(true).end(Buffer.buffer(payload));
        } else {
            httpRequest.end();
        }
    } catch (IllegalArgumentException | EncodingException ex) {
        answer.completeExceptionally(ex);
    }
    return answer;
}

From source file:org.entcore.common.elasticsearch.ElasticSearch.java

License:Open Source License

public BulkRequest bulk(String type, Handler<AsyncResult<JsonObject>> handler) {
    final ElasticSearchClient esc = getClient();
    final HttpClientRequest req = esc.client.post(defaultIndex + "/" + type + "/_bulk", event -> {
        if (event.statusCode() == 200) {
            event.bodyHandler(respBody -> handler.handle(new DefaultAsyncResult<>(new JsonObject(respBody))));
        } else {//from   w  w w.j  av  a2s  . c  o m
            handler.handle(new DefaultAsyncResult<>(new ElasticSearchException(event.statusMessage())));
        }
        esc.checkSuccess();
    });
    req.exceptionHandler(e -> checkDisableClientAfterError(esc, e));
    req.putHeader("Content-Type", "application/x-ndjson");
    req.putHeader("Accept", "application/json; charset=UTF-8");
    req.setChunked(true);
    return new BulkRequest(req);
}

From source file:org.sfs.integration.java.func.PutObject.java

License:Apache License

@Override
public Observable<HttpClientResponse> call(Void aVoid) {
    return auth.toHttpAuthorization().flatMap(new Func1<String, Observable<HttpClientResponse>>() {
        @Override//from  w  w  w  .  ja v a  2 s. com
        public Observable<HttpClientResponse> call(String s) {
            ObservableFuture<HttpClientResponse> handler = RxHelper.observableFuture();
            HttpClientRequest httpClientRequest = httpClient
                    .put("/openstackswift001/" + accountName + "/" + containerName + "/" + objectName,
                            handler::complete)
                    .exceptionHandler(handler::fail).setTimeout(20000).putHeader(AUTHORIZATION, s);
            for (String entry : headers.keySet()) {
                httpClientRequest = httpClientRequest.putHeader(entry, headers.get(entry));
            }
            httpClientRequest.setChunked(isChunked());
            httpClientRequest.end(buffer(data));
            return handler.single();
        }
    });

}