Example usage for org.apache.http.client.methods RequestBuilder setEntity

List of usage examples for org.apache.http.client.methods RequestBuilder setEntity

Introduction

In this page you can find the example usage for org.apache.http.client.methods RequestBuilder setEntity.

Prototype

public RequestBuilder setEntity(final HttpEntity entity) 

Source Link

Usage

From source file:org.apache.asterix.test.aql.TestExecutor.java

protected HttpUriRequest constructPostMethodUrl(String statement, String endpoint, String stmtParam,
        List<CompilationUnit.Parameter> otherParams) {
    RequestBuilder builder = RequestBuilder.post(endpoint);
    if (stmtParam != null) {
        for (CompilationUnit.Parameter param : injectStatement(statement, stmtParam, otherParams)) {
            builder.addParameter(param.getName(), param.getValue());
        }//from  w  w  w .  j  a va2 s. co m
        builder.addParameter(stmtParam, statement);
    } else {
        // this seems pretty bad - we should probably fix the API and not the client
        builder.setEntity(new StringEntity(statement, StandardCharsets.UTF_8));
    }
    builder.setCharset(StandardCharsets.UTF_8);
    return builder.build();
}

From source file:org.bonitasoft.connectors.rest.RESTConnector.java

/**
 * Execute a given request//from   w w  w.  ja  v  a2  s .  c o  m
 * 
 * @param request The request to execute
 * @return The response of the executed request
 * @throws Exception any exception that might occur
 */
public void execute(final Request request) throws Exception {
    CloseableHttpClient httpClient = null;

    try {
        final URL url = request.getUrl();
        final String urlHost = url.getHost();

        final Builder requestConfigurationBuilder = RequestConfig.custom();
        requestConfigurationBuilder.setConnectionRequestTimeout(CONNECTION_TIMEOUT);
        requestConfigurationBuilder.setRedirectsEnabled(request.isRedirect());

        final HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(0, false));
        setSSL(request.getSsl(), httpClientBuilder);
        setProxy(request.getProxy(), httpClientBuilder, requestConfigurationBuilder);
        setCookies(requestConfigurationBuilder, httpClientBuilder, request.getCookies(), urlHost);

        final RequestBuilder requestBuilder = getRequestBuilderFromMethod(request.getRestMethod());
        requestBuilder.setVersion(
                new ProtocolVersion(HTTP_PROTOCOL, HTTP_PROTOCOL_VERSION_MAJOR, HTTP_PROTOCOL_VERSION_MINOR));
        int urlPort = url.getPort();
        if (url.getPort() == -1) {
            urlPort = url.getDefaultPort();
        }
        final String urlProtocol = url.getProtocol();
        final String urlStr = url.toString();
        requestBuilder.setUri(urlStr);
        setHeaders(requestBuilder, request.getHeaders());
        if (!HTTPMethod.GET.equals(HTTPMethod.valueOf(requestBuilder.getMethod()))) {
            final String body = request.getBody();
            if (body != null) {
                requestBuilder.setEntity(new StringEntity(request.getBody(), request.getContentType()));
            }
        }

        final HttpContext httpContext = setAuthorizations(requestConfigurationBuilder,
                request.getAuthorization(), request.getProxy(), urlHost, urlPort, urlProtocol,
                httpClientBuilder);

        requestBuilder.setConfig(requestConfigurationBuilder.build());
        httpClientBuilder.setDefaultRequestConfig(requestConfigurationBuilder.build());

        final HttpUriRequest httpRequest = requestBuilder.build();
        httpClient = httpClientBuilder.build();
        final CloseableHttpResponse httpResponse = httpClient.execute(httpRequest, httpContext);
        LOGGER.fine("Request sent.");
        setOutputs(httpResponse, request);
    } finally {
        try {
            if (httpClient != null) {
                httpClient.close();
            }
        } catch (final IOException ex) {
            logException(ex);
        }
    }
}

From source file:org.eclipse.rdf4j.http.client.RDF4JProtocolSession.java

@Override
protected HttpUriRequest getQueryMethod(QueryLanguage ql, String query, String baseURI, Dataset dataset,
        boolean includeInferred, int maxQueryTime, Binding... bindings) {
    RequestBuilder builder = null;
    if (transactionURL != null) {
        builder = RequestBuilder.put(transactionURL);
        builder.setHeader("Content-Type", Protocol.SPARQL_QUERY_MIME_TYPE + "; charset=utf-8");
        builder.addParameter(Protocol.ACTION_PARAM_NAME, Action.QUERY.toString());
        for (NameValuePair nvp : getQueryMethodParameters(ql, null, baseURI, dataset, includeInferred,
                maxQueryTime, bindings)) {
            builder.addParameter(nvp);/*from   ww  w  .  j  av  a2 s .co  m*/
        }
        // in a PUT request, we carry the actual query string as the entity
        // body rather than a parameter.
        builder.setEntity(new StringEntity(query, UTF8));
    } else {
        builder = RequestBuilder.post(getQueryURL());
        builder.setHeader("Content-Type", Protocol.FORM_MIME_TYPE + "; charset=utf-8");

        builder.setEntity(new UrlEncodedFormEntity(
                getQueryMethodParameters(ql, query, baseURI, dataset, includeInferred, maxQueryTime, bindings),
                UTF8));
    }
    // functionality to provide custom http headers as required by the
    // applications
    for (Map.Entry<String, String> additionalHeader : getAdditionalHttpHeaders().entrySet()) {
        builder.addHeader(additionalHeader.getKey(), additionalHeader.getValue());
    }
    return builder.build();
}

From source file:org.eclipse.rdf4j.http.client.RDF4JProtocolSession.java

@Override
protected HttpUriRequest getUpdateMethod(QueryLanguage ql, String update, String baseURI, Dataset dataset,
        boolean includeInferred, int maxExecutionTime, Binding... bindings) {
    RequestBuilder builder = null;
    if (transactionURL != null) {
        builder = RequestBuilder.put(transactionURL);
        builder.addHeader("Content-Type", Protocol.SPARQL_UPDATE_MIME_TYPE + "; charset=utf-8");
        builder.addParameter(Protocol.ACTION_PARAM_NAME, Action.UPDATE.toString());
        for (NameValuePair nvp : getUpdateMethodParameters(ql, null, baseURI, dataset, includeInferred,
                maxExecutionTime, bindings)) {
            builder.addParameter(nvp);//  w  w  w . j  a v  a2 s  . c  o m
        }
        // in a PUT request, we carry the only actual update string as the
        // request body - the rest is sent as request parameters
        builder.setEntity(new StringEntity(update, UTF8));
    } else {
        builder = RequestBuilder.post(getUpdateURL());
        builder.addHeader("Content-Type", Protocol.FORM_MIME_TYPE + "; charset=utf-8");

        builder.setEntity(new UrlEncodedFormEntity(getUpdateMethodParameters(ql, update, baseURI, dataset,
                includeInferred, maxExecutionTime, bindings), UTF8));
    }
    // functionality to provide custom http headers as required by the
    // applications
    for (Map.Entry<String, String> additionalHeader : getAdditionalHttpHeaders().entrySet()) {
        builder.addHeader(additionalHeader.getKey(), additionalHeader.getValue());
    }
    return builder.build();
}

From source file:org.apache.asterix.test.common.TestExecutor.java

protected HttpUriRequest constructPostMethodJson(String statement, URI uri, String stmtParam,
        List<CompilationUnit.Parameter> otherParams) {
    if (stmtParam == null) {
        throw new NullPointerException("Statement parameter required.");
    }//from   ww w .  j av a  2s  .  com
    RequestBuilder builder = RequestBuilder.post(uri);
    ObjectMapper om = new ObjectMapper();
    ObjectNode content = om.createObjectNode();
    for (CompilationUnit.Parameter param : upsertParam(otherParams, stmtParam, statement)) {
        content.put(param.getName(), param.getValue());
    }
    try {
        builder.setEntity(new StringEntity(om.writeValueAsString(content), ContentType.APPLICATION_JSON));
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    builder.setCharset(StandardCharsets.UTF_8);
    return builder.build();
}

From source file:org.apache.asterix.test.common.TestExecutor.java

protected HttpUriRequest constructPostMethodUrl(String statement, URI uri, String stmtParam,
        List<CompilationUnit.Parameter> otherParams) {
    RequestBuilder builder = RequestBuilder.post(uri);
    if (stmtParam != null) {
        for (CompilationUnit.Parameter param : upsertParam(otherParams, stmtParam, statement)) {
            builder.addParameter(param.getName(), param.getValue());
        }/*w ww  . j a  v  a  2 s . c o m*/
        builder.addParameter(stmtParam, statement);
    } else {
        // this seems pretty bad - we should probably fix the API and not the client
        builder.setEntity(new StringEntity(statement, StandardCharsets.UTF_8));
    }
    builder.setCharset(StandardCharsets.UTF_8);
    return builder.build();
}

From source file:com.ibm.og.client.ApacheClient.java

private HttpUriRequest createRequest(final AuthenticatedRequest request) {
    final RequestBuilder builder = RequestBuilder.create(request.getMethod().toString())
            .setUri(request.getUri());/*from w w  w.j  a  va 2  s . co  m*/

    for (final Entry<String, String> header : request.headers().entrySet()) {
        builder.addHeader(header.getKey(), header.getValue());
    }

    if (DataType.NONE != request.getBody().getDataType()) {
        final AbstractHttpEntity entity = new CustomHttpEntity(request, this.writeThroughput);
        // TODO chunk size for chunked encoding is hardcoded to 2048 bytes. Can only be overridden
        // by implementing a custom connection factory
        entity.setChunked(this.chunkedEncoding);
        builder.setEntity(entity);
    }

    return builder.build();
}

From source file:feign.httpclient.ApacheHttpClient.java

HttpUriRequest toHttpUriRequest(Request request, Request.Options options)
        throws UnsupportedEncodingException, MalformedURLException, URISyntaxException {
    RequestBuilder requestBuilder = RequestBuilder.create(request.method());

    //per request timeouts
    RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(options.connectTimeoutMillis())
            .setSocketTimeout(options.readTimeoutMillis()).build();
    requestBuilder.setConfig(requestConfig);

    URI uri = new URIBuilder(request.url()).build();

    requestBuilder.setUri(uri.getScheme() + "://" + uri.getAuthority() + uri.getRawPath());

    //request query params
    List<NameValuePair> queryParams = URLEncodedUtils.parse(uri, requestBuilder.getCharset().name());
    for (NameValuePair queryParam : queryParams) {
        requestBuilder.addParameter(queryParam);
    }/*from   w ww  .  j  ava2 s  . c  o  m*/

    //request headers
    boolean hasAcceptHeader = false;
    for (Map.Entry<String, Collection<String>> headerEntry : request.headers().entrySet()) {
        String headerName = headerEntry.getKey();
        if (headerName.equalsIgnoreCase(ACCEPT_HEADER_NAME)) {
            hasAcceptHeader = true;
        }

        if (headerName.equalsIgnoreCase(Util.CONTENT_LENGTH)) {
            // The 'Content-Length' header is always set by the Apache client and it
            // doesn't like us to set it as well.
            continue;
        }

        for (String headerValue : headerEntry.getValue()) {
            requestBuilder.addHeader(headerName, headerValue);
        }
    }
    //some servers choke on the default accept string, so we'll set it to anything
    if (!hasAcceptHeader) {
        requestBuilder.addHeader(ACCEPT_HEADER_NAME, "*/*");
    }

    //request body
    if (request.body() != null) {
        HttpEntity entity = null;
        if (request.charset() != null) {
            ContentType contentType = getContentType(request);
            String content = new String(request.body(), request.charset());
            entity = new StringEntity(content, contentType);
        } else {
            entity = new ByteArrayEntity(request.body());
        }

        requestBuilder.setEntity(entity);
    }

    return requestBuilder.build();
}