Example usage for org.apache.http.nio.entity NByteArrayEntity NByteArrayEntity

List of usage examples for org.apache.http.nio.entity NByteArrayEntity NByteArrayEntity

Introduction

In this page you can find the example usage for org.apache.http.nio.entity NByteArrayEntity NByteArrayEntity.

Prototype

public NByteArrayEntity(final byte[] b) 

Source Link

Usage

From source file:marytts.server.http.MaryHttpServerUtils.java

public static void toHttpResponse(byte[] byteArray, HttpResponse response, String contentType)
        throws IOException {
    NByteArrayEntity body = new NByteArrayEntity(byteArray);
    body.setContentType(contentType);//from w ww  .  ja v a  2 s. c o m
    response.setEntity(body);
    response.setStatusCode(HttpStatus.SC_OK);
}

From source file:org.jclouds.http.httpnio.util.NioHttpUtils.java

public static void addEntityForContent(BasicHttpEntityEnclosingRequest apacheRequest, Object content,
        String contentType, long length) {
    if (content instanceof InputStream) {
        InputStream inputStream = (InputStream) content;
        if (length == -1)
            throw new IllegalArgumentException("you must specify size when content is an InputStream");
        InputStreamEntity entity = new InputStreamEntity(inputStream, length);
        entity.setContentType(contentType);
        apacheRequest.setEntity(entity);
    } else if (content instanceof String) {
        NStringEntity nStringEntity = null;
        try {//from   ww  w  .  j a va2 s  .  co m
            nStringEntity = new NStringEntity((String) content);
        } catch (UnsupportedEncodingException e) {
            throw new UnsupportedOperationException("Encoding not supported", e);
        }
        nStringEntity.setContentType(contentType);
        apacheRequest.setEntity(nStringEntity);
    } else if (content instanceof File) {
        apacheRequest.setEntity(new NFileEntity((File) content, contentType, true));
    } else if (content instanceof byte[]) {
        NByteArrayEntity entity = new NByteArrayEntity((byte[]) content);
        entity.setContentType(contentType);
        apacheRequest.setEntity(entity);
    } else {
        throw new UnsupportedOperationException("Content class not supported: " + content.getClass().getName());
    }
}

From source file:com.mashape.unirest.android.http.HttpClientHelper.java

private static HttpRequestBase prepareRequest(HttpRequest request, boolean async) {

    Object defaultHeaders = Options.getOption(Option.DEFAULT_HEADERS);
    if (defaultHeaders != null) {
        @SuppressWarnings("unchecked")
        Set<Entry<String, String>> entrySet = ((Map<String, String>) defaultHeaders).entrySet();
        for (Entry<String, String> entry : entrySet) {
            request.header(entry.getKey(), entry.getValue());
        }/*from   w  w  w .  j  a  v  a 2s  .  co m*/
    }

    if (!request.getHeaders().containsKey(USER_AGENT_HEADER)) {
        request.header(USER_AGENT_HEADER, USER_AGENT);
    }
    if (!request.getHeaders().containsKey(ACCEPT_ENCODING_HEADER)) {
        request.header(ACCEPT_ENCODING_HEADER, "gzip");
    }

    HttpRequestBase reqObj = null;

    String urlToRequest = null;
    try {
        URL url = new URL(request.getUrl());
        URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(),
                URLDecoder.decode(url.getPath(), "UTF-8"), "", url.getRef());
        urlToRequest = uri.toURL().toString();
        if (url.getQuery() != null && !url.getQuery().trim().equals("")) {
            if (!urlToRequest.substring(urlToRequest.length() - 1).equals("?")) {
                urlToRequest += "?";
            }
            urlToRequest += url.getQuery();
        } else if (urlToRequest.substring(urlToRequest.length() - 1).equals("?")) {
            urlToRequest = urlToRequest.substring(0, urlToRequest.length() - 1);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    switch (request.getHttpMethod()) {
    case GET:
        reqObj = new HttpGet(urlToRequest);
        break;
    case POST:
        reqObj = new HttpPost(urlToRequest);
        break;
    case PUT:
        reqObj = new HttpPut(urlToRequest);
        break;
    case DELETE:
        //reqObj = new HttpDeleteWithBody(urlToRequest);
        break;
    case PATCH:
        //reqObj = new HttpPatchWithBody(urlToRequest);
        break;
    case OPTIONS:
        reqObj = new HttpOptions(urlToRequest);
        break;
    case HEAD:
        reqObj = new HttpHead(urlToRequest);
        break;
    }

    Set<Entry<String, List<String>>> entrySet = request.getHeaders().entrySet();
    for (Entry<String, List<String>> entry : entrySet) {
        List<String> values = entry.getValue();
        if (values != null) {
            for (String value : values) {
                reqObj.addHeader(entry.getKey(), value);
            }
        }
    }

    // Set body
    if (!(request.getHttpMethod() == HttpMethod.GET || request.getHttpMethod() == HttpMethod.HEAD)) {
        if (request.getBody() != null) {
            HttpEntity entity = request.getBody().getEntity();
            if (async) {
                if (reqObj.getHeaders(CONTENT_TYPE) == null || reqObj.getHeaders(CONTENT_TYPE).length == 0) {
                    reqObj.setHeader(entity.getContentType());
                }
                try {
                    ByteArrayOutputStream output = new ByteArrayOutputStream();
                    entity.writeTo(output);
                    NByteArrayEntity en = new NByteArrayEntity(output.toByteArray());
                    ((HttpEntityEnclosingRequestBase) reqObj).setEntity(en);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            } else {
                ((HttpEntityEnclosingRequestBase) reqObj).setEntity(entity);
            }
        }
    }

    return reqObj;
}

From source file:org.opcfoundation.ua.transport.https.HttpsClientPendingRequest.java

@Override
public void run() {
    try {//  ww w. j a  v  a  2  s .  c o  m
        // Abort exit branch
        if (abortCode != null) {
            result.setError(new ServiceResultException(abortCode));
            return;
        }

        // Http Post
        InetSocketAddress inetAddress = UriUtil.getSocketAddress(httpsClient.connectUrl);
        String host = inetAddress.getHostName();
        int port = inetAddress.getPort();
        String scheme = UriUtil.getTransportProtocol(httpsClient.connectUrl);
        HttpHost httpHost = new HttpHost(host, port, scheme);
        String url = httpsClient.transportChannelSettings.getDescription().getEndpointUrl();
        String endpointId = url == null ? "" : url; //UriUtil.getEndpointName(url);
        httpPost = new HttpPost(endpointId);
        httpPost.addHeader("OPCUA-SecurityPolicy", httpsClient.securityPolicyUri);
        httpPost.addHeader("Content-Type", "application/octet-stream");

        // Calculate message length
        EncoderCalc calc = new EncoderCalc();
        calc.setEncoderContext(httpsClient.encoderCtx);
        calc.putMessage(requestMessage);
        int len = calc.getLength();

        // Assert max size is not exceeded
        int maxLen = httpsClient.encoderCtx.getMaxMessageSize();
        if (maxLen != 0 && len > maxLen) {
            final EncodingException encodingException = new EncodingException(
                    StatusCodes.Bad_EncodingLimitsExceeded, "MaxStringLength " + maxLen + " < " + len);
            logger.warn("run: failed", encodingException);
            throw encodingException;
        }

        // Encode message
        byte[] data = new byte[len];
        BinaryEncoder enc = new BinaryEncoder(data);
        enc.setEncoderContext(httpsClient.encoderCtx);
        enc.setEncoderMode(EncoderMode.NonStrict);
        enc.putMessage(requestMessage);
        httpPost.setEntity(new NByteArrayEntity(data));

        // Abort exit branch
        if (abortCode != null) {
            result.setError(new ServiceResultException(abortCode));
            return;
        }

        // Execute Post

        HttpResponse httpResponse;
        try {
            httpResponse = httpsClient.httpclient.execute(httpHost, httpPost);
        } catch (SSLPeerUnverifiedException e) {
            // Currently, TLS_1_2 is not supported by JSSE implementations, for some odd reason
            // and it will give this exception when used.
            // Also, if the server certificate is rejected, we will get this error
            result.setError(new ServiceResultException(StatusCodes.Bad_SecurityPolicyRejected, e,
                    "Could not negotiate a TLS security cipher or the server did not provide a valid certificate."));
            return;
        }
        HttpEntity entity = httpResponse.getEntity();

        // Error response
        int statusCode = httpResponse.getStatusLine().getStatusCode();
        if (statusCode != 200) {
            UnsignedInteger uacode = StatusCodes.Bad_UnknownResponse;
            if (statusCode == 501)
                uacode = StatusCodes.Bad_ServiceUnsupported;
            String msg = EntityUtils.toString(entity);
            result.setError(new ServiceResultException(uacode, statusCode + ": " + msg));
            return;
        }

        // Abort exit branch
        if (abortCode != null) {
            result.setError(new ServiceResultException(abortCode));
            return;
        }

        // Decode Message
        data = EntityUtils.toByteArray(entity);

        BinaryDecoder dec = new BinaryDecoder(data);
        dec.setEncoderContext(httpsClient.encoderCtx);
        IEncodeable response = dec.getMessage();

        // Client sent an error
        if (response instanceof ErrorMessage) {
            ErrorMessage error = (ErrorMessage) response;
            ServiceResultException errorResult = new ServiceResultException(new StatusCode(error.getError()),
                    error.getReason());
            result.setError(errorResult);
            return;
        }

        try {
            // Client sent a valid message
            result.setResult((ServiceResponse) response);
        } catch (ClassCastException e) {
            result.setError(new ServiceResultException(e));
            logger.error("Cannot cast response to ServiceResponse, response=" + response.getClass(), e);
        }
    } catch (EncodingException e) {
        // Internal Error
        result.setError(new ServiceResultException(StatusCodes.Bad_EncodingError, e));
    } catch (ClientProtocolException e) {
        result.setError(new ServiceResultException(StatusCodes.Bad_CommunicationError, e));
    } catch (IOException e) {
        if (abortCode != null) {
            result.setError(new ServiceResultException(abortCode, e));
        } else {
            result.setError(new ServiceResultException(StatusCodes.Bad_CommunicationError, e));
        }
    } catch (DecodingException e) {
        result.setError(new ServiceResultException(StatusCodes.Bad_DecodingError, e));
    } catch (ServiceResultException e) {
        result.setError(e);
    } catch (RuntimeException rte) {
        // http-client seems to be throwing these, IllegalArgumentException for one
        result.setError(new ServiceResultException(rte));
    } finally {
        httpsClient.requests.remove(requestId);
    }
}

From source file:org.rapidoid.http.HttpClientUtil.java

private static NByteArrayEntity byteBody(HttpReq config) {
    NByteArrayEntity entity = new NByteArrayEntity(config.body());

    if (config.contentType() != null) {
        entity.setContentType(config.contentType());
    }//from w  w w. j  a v  a 2s  . c om
    return entity;
}

From source file:org.opcfoundation.ua.transport.https.HttpsServerPendingRequest.java

void sendResponse(int statusCode, IEncodeable responseObject) {
    try {//w w  w.jav a2  s  . c om
        HttpResponse responseHandle = httpExchange.getResponse();
        responseHandle.setHeader("Content-Type", "application/octet-stream");
        responseHandle.setStatusCode(statusCode);

        if (responseObject != null) {
            try {
                logger.trace("sendResponse: requestId={} statusCode={} responseObject={}", requestId,
                        statusCode, responseObject);
                logger.debug("sendResponse: requestId={} statusCode={} responseObject={}", requestId,
                        statusCode, responseObject.getClass().getSimpleName());

                //Check isDebugEnabled() here for possible performance reasons.
                if (logger.isDebugEnabled() && channel.getConnection() != null) {
                    NHttpServerConnection nHttpServerConnection = ((HttpsServerConnection) channel
                            .getConnection()).getNHttpServerConnection();
                    logger.debug("sendResponse: timeout={} {} context={}", httpExchange.getTimeout(),
                            nHttpServerConnection.getSocketTimeout(), nHttpServerConnection.getContext());
                }
                EncoderCalc calc = new EncoderCalc();
                calc.setEncoderContext(endpoint.getEncoderContext());
                calc.putMessage(responseObject);
                int len = calc.getLength();
                byte[] data = new byte[len];
                BinaryEncoder enc = new BinaryEncoder(data);
                enc.setEncoderContext(endpoint.getEncoderContext());
                enc.setEncoderMode(EncoderMode.NonStrict);
                enc.putMessage(responseObject);
                responseHandle.setEntity(new NByteArrayEntity(data));
            } catch (EncodingException e) {
                logger.info("sendResponse: Encoding failed", e);
                // Internal Error
                if (responseObject instanceof ErrorMessage == false) {
                    responseHandle.setStatusCode(500);
                }
            }
        }
        logger.debug("sendResponse: {} length={}", responseHandle,
                responseHandle.getEntity().getContentLength());
        httpExchange.submitResponse(new BasicAsyncResponseProducer(responseHandle));
    } finally {
        endpoint.pendingRequests.remove(requestId);
    }
}

From source file:net.ychron.unirestinst.http.HttpClientHelper.java

private HttpRequestBase prepareRequest(HttpRequest request, boolean async) {

    Object defaultHeaders = options.getOption(Option.DEFAULT_HEADERS);
    if (defaultHeaders != null) {
        @SuppressWarnings("unchecked")
        Set<Entry<String, String>> entrySet = ((Map<String, String>) defaultHeaders).entrySet();
        for (Entry<String, String> entry : entrySet) {
            request.header(entry.getKey(), entry.getValue());
        }/*from w w  w .j  a  v a 2 s.c  om*/
    }

    if (!request.getHeaders().containsKey(USER_AGENT_HEADER)) {
        request.header(USER_AGENT_HEADER, USER_AGENT);
    }
    if (!request.getHeaders().containsKey(ACCEPT_ENCODING_HEADER)) {
        request.header(ACCEPT_ENCODING_HEADER, "gzip");
    }

    HttpRequestBase reqObj = null;

    String urlToRequest = null;
    try {
        URL url = new URL(request.getUrl());
        URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(),
                URLDecoder.decode(url.getPath(), "UTF-8"), "", url.getRef());
        urlToRequest = uri.toURL().toString();
        if (url.getQuery() != null && !url.getQuery().trim().equals("")) {
            if (!urlToRequest.substring(urlToRequest.length() - 1).equals("?")) {
                urlToRequest += "?";
            }
            urlToRequest += url.getQuery();
        } else if (urlToRequest.substring(urlToRequest.length() - 1).equals("?")) {
            urlToRequest = urlToRequest.substring(0, urlToRequest.length() - 1);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    switch (request.getHttpMethod()) {
    case GET:
        reqObj = new HttpGet(urlToRequest);
        break;
    case POST:
        reqObj = new HttpPost(urlToRequest);
        break;
    case PUT:
        reqObj = new HttpPut(urlToRequest);
        break;
    case DELETE:
        reqObj = new HttpDeleteWithBody(urlToRequest);
        break;
    case PATCH:
        reqObj = new HttpPatchWithBody(urlToRequest);
        break;
    case OPTIONS:
        reqObj = new HttpOptions(urlToRequest);
        break;
    case HEAD:
        reqObj = new HttpHead(urlToRequest);
        break;
    }

    Set<Entry<String, List<String>>> entrySet = request.getHeaders().entrySet();
    for (Entry<String, List<String>> entry : entrySet) {
        List<String> values = entry.getValue();
        if (values != null) {
            for (String value : values) {
                reqObj.addHeader(entry.getKey(), value);
            }
        }
    }

    // Set body
    if (!(request.getHttpMethod() == HttpMethod.GET || request.getHttpMethod() == HttpMethod.HEAD)) {
        if (request.getBody() != null) {
            HttpEntity entity = request.getBody().getEntity();
            if (async) {
                if (reqObj.getHeaders(CONTENT_TYPE) == null || reqObj.getHeaders(CONTENT_TYPE).length == 0) {
                    reqObj.setHeader(entity.getContentType());
                }
                try {
                    ByteArrayOutputStream output = new ByteArrayOutputStream();
                    entity.writeTo(output);
                    NByteArrayEntity en = new NByteArrayEntity(output.toByteArray());
                    ((HttpEntityEnclosingRequestBase) reqObj).setEntity(en);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            } else {
                ((HttpEntityEnclosingRequestBase) reqObj).setEntity(entity);
            }
        }
    }

    return reqObj;
}

From source file:com.google.acre.script.NHttpClient.java

public void fetch(String url, String method, Map<String, String> headers, byte[] body, long timeout,
        boolean no_redirect, NHttpClientCallback callback) throws NHttpException {
    URL u;//w w  w  . ja va  2  s .  c  o  m
    String path;
    HttpRequest req;

    try {
        u = new URL(url);
    } catch (MalformedURLException e) {
        throw new NHttpException(e);
    }

    // Proxies expect the entire URL as the path
    if (_proxy == null || !_proxy.use_proxy(url)) {
        path = u.getPath();
        if (path.equals("")) {
            path = "/";
        }

        if (u.getQuery() != null) {
            path += "?" + u.getQuery();
        }
    } else {
        path = url;
    }

    if ((method.equalsIgnoreCase("POST") || method.equalsIgnoreCase("PUT")) && body.length > 0) {
        req = new BasicHttpEntityEnclosingRequest(method, path);
        NByteArrayEntity bae = new NByteArrayEntity(body);
        ((HttpEntityEnclosingRequest) req).setEntity(bae);

    } else {
        req = new BasicHttpRequest(method, path);
    }

    if (headers != null) {
        for (Map.Entry<String, String> header : headers.entrySet()) {
            req.addHeader(header.getKey(), header.getValue());
        }
    }

    if (req instanceof HttpEntityEnclosingRequest)
        req.removeHeaders("Content-Length");
    fetch(u, req, timeout, no_redirect, callback);
}

From source file:org.rapidoid.http.HttpClient.java

public Future<byte[]> request(String verb, String uri, Map<String, String> headers, Map<String, String> data,
        Map<String, String> files, byte[] body, String contentType, Callback<byte[]> callback,
        boolean fullResponse) {

    headers = U.safe(headers);/*from   w w w  .j a  v a  2 s  .c  o  m*/
    data = U.safe(data);
    files = U.safe(files);

    HttpRequestBase req;
    boolean canHaveBody = false;

    if ("GET".equalsIgnoreCase(verb)) {
        req = new HttpGet(uri);
    } else if ("DELETE".equalsIgnoreCase(verb)) {
        req = new HttpDelete(uri);
    } else if ("OPTIONS".equalsIgnoreCase(verb)) {
        req = new HttpOptions(uri);
    } else if ("HEAD".equalsIgnoreCase(verb)) {
        req = new HttpHead(uri);
    } else if ("TRACE".equalsIgnoreCase(verb)) {
        req = new HttpTrace(uri);
    } else if ("POST".equalsIgnoreCase(verb)) {
        req = new HttpPost(uri);
        canHaveBody = true;
    } else if ("PUT".equalsIgnoreCase(verb)) {
        req = new HttpPut(uri);
        canHaveBody = true;
    } else if ("PATCH".equalsIgnoreCase(verb)) {
        req = new HttpPatch(uri);
        canHaveBody = true;
    } else {
        throw U.illegalArg("Illegal HTTP verb: " + verb);
    }

    for (Entry<String, String> e : headers.entrySet()) {
        req.addHeader(e.getKey(), e.getValue());
    }

    if (canHaveBody) {
        HttpEntityEnclosingRequestBase entityEnclosingReq = (HttpEntityEnclosingRequestBase) req;

        if (body != null) {

            NByteArrayEntity entity = new NByteArrayEntity(body);

            if (contentType != null) {
                entity.setContentType(contentType);
            }

            entityEnclosingReq.setEntity(entity);
        } else {

            MultipartEntityBuilder builder = MultipartEntityBuilder.create();

            for (Entry<String, String> entry : files.entrySet()) {
                String filename = entry.getValue();
                File file = IO.file(filename);
                builder = builder.addBinaryBody(entry.getKey(), file, ContentType.DEFAULT_BINARY, filename);
            }

            for (Entry<String, String> entry : data.entrySet()) {
                builder = builder.addTextBody(entry.getKey(), entry.getValue(), ContentType.DEFAULT_TEXT);
            }

            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            try {
                builder.build().writeTo(stream);
            } catch (IOException e) {
                throw U.rte(e);
            }

            byte[] bytes = stream.toByteArray();
            NByteArrayEntity entity = new NByteArrayEntity(bytes, ContentType.MULTIPART_FORM_DATA);

            entityEnclosingReq.setEntity(entity);
        }
    }

    Log.debug("Starting HTTP request", "request", req.getRequestLine());

    return execute(client, req, callback, fullResponse);
}