Example usage for org.apache.http.client.methods HttpUriRequest headerIterator

List of usage examples for org.apache.http.client.methods HttpUriRequest headerIterator

Introduction

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

Prototype

HeaderIterator headerIterator();

Source Link

Usage

From source file:ch.entwine.weblounge.common.impl.util.TestUtils.java

/**
 * Issues the the given request./*from   w w  w.j  av a2s  .c  o  m*/
 * 
 * @param httpClient
 *          the http client
 * @param request
 *          the request
 * @param params
 *          the request parameters
 * @throws Exception
 *           if the request fails
 */
public static HttpResponse request(HttpClient httpClient, HttpUriRequest request, String[][] params)
        throws Exception {
    if (params != null) {
        if (request instanceof HttpGet) {
            List<NameValuePair> qparams = new ArrayList<NameValuePair>();
            if (params.length > 0) {
                for (String[] param : params) {
                    if (param.length < 2)
                        continue;
                    qparams.add(new BasicNameValuePair(param[0], param[1]));
                }
            }
            URI requestURI = request.getURI();
            URI uri = URIUtils.createURI(requestURI.getScheme(), requestURI.getHost(), requestURI.getPort(),
                    requestURI.getPath(), URLEncodedUtils.format(qparams, "utf-8"), null);
            HeaderIterator headerIterator = request.headerIterator();
            request = new HttpGet(uri);
            while (headerIterator.hasNext()) {
                request.addHeader(headerIterator.nextHeader());
            }
        } else if (request instanceof HttpPost) {
            List<NameValuePair> formparams = new ArrayList<NameValuePair>();
            for (String[] param : params)
                formparams.add(new BasicNameValuePair(param[0], param[1]));
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, "utf-8");
            ((HttpPost) request).setEntity(entity);
        } else if (request instanceof HttpPut) {
            List<NameValuePair> formparams = new ArrayList<NameValuePair>();
            for (String[] param : params)
                formparams.add(new BasicNameValuePair(param[0], param[1]));
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, "utf-8");
            ((HttpPut) request).setEntity(entity);
        }
    } else {
        if (request instanceof HttpPost || request instanceof HttpPut) {
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(new ArrayList<NameValuePair>(), "utf-8");
            ((HttpEntityEnclosingRequestBase) request).setEntity(entity);
        }
    }
    return httpClient.execute(request);
}

From source file:org.ecloudmanager.tmrk.cloudapi.CloudapiRequestAuhtorization.java

private String signature(HttpUriRequest request, String apiPrivateKey) {
    StringBuilder sb = new StringBuilder();
    String verb = request.getMethod().toUpperCase();
    String date = request.getFirstHeader(HttpHeaderNames.DATE).getValue();
    Header contentTypeHeader = request.getFirstHeader(HttpHeaderNames.CONTENT_TYPE);
    String contentType = contentTypeHeader != null ? contentTypeHeader.getValue() : null;
    Header contentLengthHeader = request.getFirstHeader(HttpHeaderNames.CONTENT_LENGTH);
    String contentLength = contentLengthHeader != null ? contentLengthHeader.getValue() : null;

    sb.append(verb).append("\n");
    sb.append(contentLength != null ? contentLength.trim() : "").append("\n");
    sb.append(contentType != null ? contentType.trim() : "").append("\n");
    sb.append(date).append("\n");
    HeaderIterator hit = request.headerIterator();
    Headers<Object> headers = new Headers<>();
    while (hit.hasNext()) {
        Header hdr = hit.nextHeader();//  w w  w  . j a  v a2 s  .  com
        headers.add(hdr.getName(), hdr.getValue());
    }
    sb.append(canonicalizedHeaders(headers));
    sb.append(canonicalizedResource(new ResteasyUriInfo(request.getURI())));

    String sigstr = sb.toString();
    try {
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(getBytes(apiPrivateKey), "HmacSHA256");
        sha256_HMAC.init(secret_key);

        return Base64.encodeBytes(sha256_HMAC.doFinal(getBytes(sigstr)));
    } catch (Exception e) {
        e.printStackTrace();
    }

    return null;
}

From source file:com.android.aft.AFNetworkConnection.AFNetworkConnection.java

private HttpResponse makeRequest(HttpClient client, HttpUriRequest uri_request,
        AFNetworkConnectionRequest request) throws ClientProtocolException, IOException {

    HttpResponse response;/* www . j  av a2  s.  c  o  m*/
    // try {

    // Activate the gzip compression if asked
    if (request.isGzipEnabled) {
        AndroidHttpClient.modifyRequestToAcceptGzipResponse(uri_request);
    }

    if (AFConfig.INFO_LOGS_ENABLED) {
        Log.i(LOG_TAG, "retrieveStringFromService - Request - headers list (name => value) : ");

        final HeaderIterator iterator = uri_request.headerIterator();
        while (iterator.hasNext()) {
            final Header header = iterator.nextHeader();
            Log.i(LOG_TAG, "- " + header.getName() + " => " + header.getValue());
        }
    }

    if (AFConfig.DEBUG_LOGS_ENABLED) {
        Log.d(LOG_TAG, "retrieveStringFromService - Executing the request");
    }
    if (mHttpContext != null)
        response = client.execute(uri_request, mHttpContext);
    else
        response = client.execute(uri_request);
    if (AFConfig.INFO_LOGS_ENABLED) {
        Log.i(LOG_TAG, "retrieveStringFromService - Response - headers list (name => value) : ");
        for (Header header : response.getAllHeaders()) {
            Log.i(LOG_TAG, String.format("- %s => %s", header.getName(), header.getValue()));
        }
    }

    return response;
}

From source file:com.llkj.cm.restfull.network.NetworkConnection.java

private static NetworkConnectionResult retrieveResponseFromService(final String url, final int method,
        final Map<String, String> parameters, final ArrayList<Header> headers, final boolean isGzipEnabled,
        final String userAgent, final String postText, final ArrayList<String> previousUrlList,
        int connectionTimeout, int soTimeout)
        throws IllegalStateException, IOException, URISyntaxException, RestClientException {
    // Get the request URL
    if (url == null) {
        if (LogConfig.DP_ERROR_LOGS_ENABLED) {
            Log.e(LOG_TAG, "retrieveResponseFromService - Compulsory Parameter : request URL has not been set");
        }/*from w w w. j a  v  a  2  s.  c o m*/
        throw new CompulsoryParameterException("Request URL has not been set");
    }
    if (LogConfig.DP_DEBUG_LOGS_ENABLED) {
        Log.d(LOG_TAG, "retrieveResponseFromService - Request url : " + url);
    }

    // Get the request method
    if (method != METHOD_GET && method != METHOD_POST && method != METHOD_PUT && method != METHOD_DELETE) {
        if (LogConfig.DP_ERROR_LOGS_ENABLED) {
            Log.e(LOG_TAG,
                    "retrieveResponseFromService - Request method must be METHOD_GET, METHOD_POST, METHOD_PUT or METHOD_DELETE");
        }
        throw new IllegalArgumentException(
                "retrieveResponseFromService - Request method must be METHOD_GET, METHOD_POST, METHOD_PUT or METHOD_DELETE");
    }
    if (LogConfig.DP_DEBUG_LOGS_ENABLED) {
        Log.d(LOG_TAG, "retrieveResponseFromService - Request method : " + method);
    }

    // Get the request parameters
    if (LogConfig.DP_DEBUG_LOGS_ENABLED) {
        Log.d(LOG_TAG, "retrieveResponseFromService - Request parameters (number) : "
                + ((parameters != null) ? parameters.size() : ""));
    }

    // Get the request headers
    if (LogConfig.DP_DEBUG_LOGS_ENABLED) {
        Log.d(LOG_TAG, "retrieveResponseFromService - Request headers (number) : "
                + ((headers != null) ? headers.size() : ""));
    }

    // Create the Request
    final AndroidHttpClient client = AndroidHttpClient
            .newInstance(userAgent != null ? userAgent : sDefaultUserAgent);
    if (connectionTimeout != -1) {
        HttpConnectionParams.setConnectionTimeout(client.getParams(), connectionTimeout);
    }
    if (soTimeout != -1) {
        HttpConnectionParams.setSoTimeout(client.getParams(), soTimeout);
    }

    if (LogConfig.DP_DEBUG_LOGS_ENABLED) {
        Log.d(LOG_TAG, "retrieveResponseFromService - Request user agent : " + userAgent);
    }

    try {
        HttpUriRequest request = null;
        switch (method) {
        case METHOD_GET:
        case METHOD_DELETE: {
            final StringBuffer sb = new StringBuffer();
            sb.append(url);

            // Add the parameters to the GET url if any
            if (parameters != null && !parameters.isEmpty()) {
                sb.append("&");

                final ArrayList<String> keyList = new ArrayList<String>(parameters.keySet());
                final int keyListLength = keyList.size();

                for (int i = 0; i < keyListLength; i++) {
                    final String key = keyList.get(i);

                    sb.append(URLEncoder.encode(key, "UTF-8"));
                    sb.append("=");
                    sb.append(URLEncoder.encode(parameters.get(key), "UTF-8"));
                    sb.append("&");
                }
            }

            if (LogConfig.DP_INFO_LOGS_ENABLED) {
                Log.i(LOG_TAG,
                        "retrieveResponseFromService - GET Request - complete URL with parameters if any : ");
                final String completeUrl = sb.toString();
                int pos = 0;
                int dumpLength = completeUrl.length();
                while (pos < dumpLength) {
                    Log.i(LOG_TAG, completeUrl.substring(pos, Math.min(dumpLength - 1, pos + 120)));
                    pos = pos + 120;
                }
            }

            final URI uri = new URI(sb.toString());

            if (method == METHOD_GET) {
                request = new HttpGet(uri);
            } else if (method == METHOD_DELETE) {
                request = new HttpDelete(uri);
            }
            break;
        }
        case METHOD_POST:
        case METHOD_PUT: {
            final URI uri = new URI(url);
            if (method == METHOD_POST) {
                request = new HttpPost(uri);
            } else if (method == METHOD_PUT) {
                request = new HttpPut(uri);
            }

            // Add the parameters to the POST request if any
            if (parameters != null && !parameters.isEmpty()) {

                final List<NameValuePair> postRequestParameters = new ArrayList<NameValuePair>();
                final ArrayList<String> keyList = new ArrayList<String>(parameters.keySet());
                final int keyListLength = keyList.size();

                for (int i = 0; i < keyListLength; i++) {
                    final String key = keyList.get(i);
                    postRequestParameters.add(new BasicNameValuePair(key, parameters.get(key)));
                }

                if (LogConfig.DP_INFO_LOGS_ENABLED) {
                    Log.i(LOG_TAG,
                            "retrieveResponseFromService - POST Request - parameters list (key => value) : ");

                    final int postRequestParametersLength = postRequestParameters.size();
                    for (int i = 0; i < postRequestParametersLength; i++) {
                        final NameValuePair nameValuePair = postRequestParameters.get(i);
                        Log.i(LOG_TAG, "- " + nameValuePair.getName() + " => " + nameValuePair.getValue());
                    }
                }

                request.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");

                if (method == METHOD_POST) {
                    ((HttpPost) request).setEntity(new UrlEncodedFormEntity(postRequestParameters, "UTF-8"));
                } else if (method == METHOD_PUT) {
                    ((HttpPut) request).setEntity(new UrlEncodedFormEntity(postRequestParameters, "UTF-8"));
                }
            } else if (null != postText) { // Add post text (send xml
                                           // for
                                           // example)
                if (method == METHOD_POST) {
                    ((HttpPost) request).setEntity(new StringEntity(postText));
                } else if (method == METHOD_PUT) {
                    ((HttpPut) request).setEntity(new StringEntity(postText));
                }

            }
            break;
        }
        default: {
            if (LogConfig.DP_ERROR_LOGS_ENABLED) {
                Log.e(LOG_TAG,
                        "retrieveResponseFromService - Request method must be METHOD_GET, METHOD_POST, METHOD_PUT or METHOD_DELETE");
            }
            throw new IllegalArgumentException(
                    "retrieveResponseFromService - Request method must be METHOD_GET, METHOD_POST, METHOD_PUT or METHOD_DELETE");
        }
        }

        // Activate the gzip compression if asked
        if (isGzipEnabled) {
            AndroidHttpClient.modifyRequestToAcceptGzipResponse(request);
        }

        if (LogConfig.DP_INFO_LOGS_ENABLED) {
            Log.i(LOG_TAG, "retrieveResponseFromService - Request - headers list (name => value) : ");

            final HeaderIterator iterator = request.headerIterator();
            while (iterator.hasNext()) {
                final Header header = iterator.nextHeader();
                Log.i(LOG_TAG, "- " + header.getName() + " => " + header.getValue());
            }
        }

        // Add the request headers if any
        if (headers != null && !headers.isEmpty()) {

            final int headersLength = headers.size();

            for (int i = 0; i < headersLength; i++) {
                request.addHeader(headers.get(i));
            }
        }

        // Launch the request
        String result = null;
        if (LogConfig.DP_DEBUG_LOGS_ENABLED) {
            Log.d(LOG_TAG, "retrieveResponseFromService - Executing the request");
        }
        final HttpResponse response = client.execute(request);

        // Get the response status
        final StatusLine status = response.getStatusLine();
        if (LogConfig.DP_DEBUG_LOGS_ENABLED) {
            Log.d(LOG_TAG, "retrieveResponseFromService - Response status : " + status.getStatusCode());
        }
        final int statusCode = status.getStatusCode();
        if (statusCode != HttpStatus.SC_OK) {
            if (LogConfig.DP_ERROR_LOGS_ENABLED) {
                Log.e(LOG_TAG,
                        "retrieveResponseFromService - Invalid response from server : " + status.toString());
            }
            if (statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
                final Header newLocation = response.getFirstHeader("Location");
                if (LogConfig.DP_INFO_LOGS_ENABLED) {
                    Log.i(LOG_TAG, "retrieveResponseFromService - New location : " + newLocation.getValue());
                }
                NewLocation.noticeNewLocation(newLocation.getValue(), url);
                //                    throw new RestClientException("New location : " + newLocation, newLocation.getValue());
            } else if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY) {
                if (method == METHOD_GET) {
                    final String newUrl = response.getHeaders("Location")[0].getValue();
                    if (!previousUrlList.contains(newUrl)) {
                        Log.d(LOG_TAG,
                                "retrieveResponseFromService - Url moved permanently - Trying the new url : "
                                        + newUrl);
                        previousUrlList.add(newUrl);
                        return retrieveResponseFromService(newUrl, method, parameters, headers, isGzipEnabled,
                                userAgent, postText);
                    } else {
                        // It's an url already checked. We are in a loop. So let's throw an Exception
                        throw new RestClientException("Moved permanently - Loop detected", statusCode);
                    }
                } else {
                    throw new RestClientException("Invalid response from server : ", statusCode);
                }
            } else {
                throw new RestClientException("Invalid response from server : ", statusCode);
            }
        }

        // Get the response entity
        final HttpEntity entity = response.getEntity();

        final Header contentEncoding = response.getFirstHeader("Content-Encoding");

        if (entity != null) {
            result = convertStreamToString(entity.getContent(),
                    contentEncoding != null && contentEncoding.getValue().equalsIgnoreCase("gzip"), method,
                    (int) entity.getContentLength());
        }

        if (LogConfig.DP_INFO_LOGS_ENABLED) {
            Log.i(LOG_TAG, "retrieveResponseFromService - Result from webservice : " + result);
        }

        return new NetworkConnectionResult(statusCode, response.getAllHeaders(), result);

    } finally {
        client.close();
    }
}

From source file:org.apache.http.impl.nio.client.MainClientExec.java

@Override
public void responseCompleted(final InternalState state, final AbstractClientExchangeHandler<?> handler)
        throws IOException, HttpException {
    final HttpClientContext localContext = state.getLocalContext();
    final HttpResponse currentResponse = handler.getCurrentResponse();

    if (!handler.isRouteEstablished()) {
        final int status = currentResponse.getStatusLine().getStatusCode();
        if (status == HttpStatus.SC_OK) {
            handler.setCurrentResponse(null);
            return;
        }/*from w w  w.j ava2  s.c  o  m*/
    }

    final boolean keepAlive = handler.manageConnectionPersistence();
    if (!keepAlive) {
        handler.releaseConnection();
        final AuthState proxyAuthState = localContext.getProxyAuthState();
        if (proxyAuthState.getState() == AuthProtocolState.SUCCESS && proxyAuthState.getAuthScheme() != null
                && proxyAuthState.getAuthScheme().isConnectionBased()) {
            if (this.log.isDebugEnabled()) {
                this.log.debug("[exchange: " + state.getId() + "] Resetting proxy auth state");
            }
            proxyAuthState.reset();
        }
        final AuthState targetAuthState = localContext.getTargetAuthState();
        if (targetAuthState.getState() == AuthProtocolState.SUCCESS && targetAuthState.getAuthScheme() != null
                && targetAuthState.getAuthScheme().isConnectionBased()) {
            if (this.log.isDebugEnabled()) {
                this.log.debug("[exchange: " + state.getId() + "] Resetting target auth state");
            }
            targetAuthState.reset();
        }
    }

    Object userToken = localContext.getUserToken();
    if (userToken == null) {
        userToken = this.userTokenHandler.getUserToken(localContext);
        localContext.setAttribute(HttpClientContext.USER_TOKEN, userToken);
    }

    if (state.getFinalResponse() != null) {
        final HttpAsyncResponseConsumer<?> responseConsumer = state.getResponseConsumer();
        responseConsumer.responseCompleted(localContext);
        if (this.log.isDebugEnabled()) {
            this.log.debug("[exchange: " + state.getId() + "] Response processed");
        }
        handler.releaseConnection();
    } else {
        if (state.getRedirect() != null) {
            final HttpUriRequest redirect = state.getRedirect();
            final URI uri = redirect.getURI();
            if (this.log.isDebugEnabled()) {
                this.log.debug("[exchange: " + state.getId() + "] Redirecting to '" + uri + "'");
            }
            state.setRedirect(null);

            final HttpHost newTarget = URIUtils.extractHost(uri);
            if (newTarget == null) {
                throw new ProtocolException("Redirect URI does not specify a valid host name: " + uri);
            }

            // Reset auth states if redirecting to another host
            final HttpRoute route = handler.getRoute();
            if (!route.getTargetHost().equals(newTarget)) {
                final AuthState targetAuthState = localContext.getTargetAuthState();
                if (this.log.isDebugEnabled()) {
                    this.log.debug("[exchange: " + state.getId() + "] Resetting target auth state");
                }
                targetAuthState.reset();
                final AuthState proxyAuthState = localContext.getProxyAuthState();
                final AuthScheme authScheme = proxyAuthState.getAuthScheme();
                if (authScheme != null && authScheme.isConnectionBased()) {
                    if (this.log.isDebugEnabled()) {
                        this.log.debug("[exchange: " + state.getId() + "] Resetting proxy auth state");
                    }
                    proxyAuthState.reset();
                }
            }

            if (!redirect.headerIterator().hasNext()) {
                final HttpRequest original = state.getMainRequest().getOriginal();
                redirect.setHeaders(original.getAllHeaders());
            }

            final HttpRequestWrapper newRequest = HttpRequestWrapper.wrap(redirect);
            final HttpRoute newRoute = this.routePlanner.determineRoute(newTarget, newRequest, localContext);
            if (!route.equals(newRoute)) {
                handler.releaseConnection();
            }
            handler.setRoute(newRoute);
            handler.setCurrentRequest(newRequest);
            state.setMainRequest(newRequest);
            prepareRequest(state, handler);
        }
    }
    handler.setCurrentResponse(null);
}