Examples with HttpEntity org.apache.http.HttpEntity used on opensource projects

Example 86 with HttpEntity

use of org.apache.http.HttpEntity in project spark by perwendel.

the class SparkTestUtil method doMethod.

public UrlResponse doMethod(String requestMethod, String path, String body, boolean secureConnection, String acceptType, Map<String, String> reqHeaders) throws IOException {
    HttpUriRequest httpRequest = getHttpRequest(requestMethod, path, body, secureConnection, acceptType, reqHeaders);
    HttpResponse httpResponse = httpClient.execute(httpRequest);
    UrlResponse urlResponse = new UrlResponse();
    urlResponse.status = httpResponse.getStatusLine().getStatusCode();
    HttpEntity entity = httpResponse.getEntity();
    if (entity != null) {
        urlResponse.body = EntityUtils.toString(entity);
    } else {
        urlResponse.body = "";
    }
    Map<String, String> headers = new HashMap<>();
    Header[] allHeaders = httpResponse.getAllHeaders();
    for (Header header : allHeaders) {
        headers.put(header.getName(), header.getValue());
    }
    urlResponse.headers = headers;
    return urlResponse;
}

Example 87 with HttpEntity

use of org.apache.http.HttpEntity in project howabout-android by recomio.

the class GroovesharkStreamUrlGetter method parseGroovesharkGetCommunicationToken.

public void parseGroovesharkGetCommunicationToken(JSONObject jsonResponseObject) throws JSONException, UnsupportedEncodingException {
    String lastRandomizer = generateRandomString(6);
    String communicationToken = jsonResponseObject.getString("result");
    String tokenSource = "getStreamKeyFromSongIDEx:" + communicationToken + ":gooeyFlubber:" + lastRandomizer;
    String token = lastRandomizer + bytesToHex(sha1.digest(tokenSource.getBytes()));
    JSONObject headerObject = new JSONObject();
    headerObject.put("client", "mobileshark");
    headerObject.put("clientRevision", "20120830");
    headerObject.put("privacy", "0");
    headerObject.put("country", country);
    headerObject.put("uuid", uuid);
    headerObject.put("session", sessionId);
    headerObject.put("token", token);
    JSONObject parametersObject = new JSONObject();
    parametersObject.put("prefetch", false);
    parametersObject.put("mobile", true);
    parametersObject.put("songID", songId);
    parametersObject.put("country", country);
    JSONObject bodyObject = new JSONObject();
    bodyObject.put("header", headerObject);
    bodyObject.put("method", "getStreamKeyFromSongIDEx");
    bodyObject.put("parameters", parametersObject);
    String groovesharkGetStreamKeyUrl = "https://html5.grooveshark.com/more.php?getStreamKeyFromSongIDEx";
    AjaxCallback<JSONObject> groovesharkGetStreamKeyAjaxCallback = new AjaxCallback<JSONObject>();
    groovesharkGetStreamKeyAjaxCallback.url(groovesharkGetStreamKeyUrl).type(JSONObject.class).handler(this, "groovesharkGetStreamKeyCallback");
    HttpEntity bodyEntity = new StringEntity(bodyObject.toString());
    Map<String, Object> params = new HashMap<String, Object>();
    params.put(AQuery.POST_ENTITY, bodyEntity);
    groovesharkGetStreamKeyAjaxCallback.params(params);
    groovesharkGetStreamKeyAjaxCallback.header("Content-Type", "application/json");
    groovesharkGetStreamKeyAjaxCallback.header("Accept", "application/json");
    groovesharkGetStreamKeyAjaxCallback.header("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.3");
    groovesharkGetStreamKeyAjaxCallback.header("Accept-Language", "en-US,en;q=0.8");
    groovesharkGetStreamKeyAjaxCallback.header("Cache-Control", "no-cache");
    groovesharkGetStreamKeyAjaxCallback.header("Connection", "keep-alive");
    groovesharkGetStreamKeyAjaxCallback.header("Host", "html5.grooveshark.com");
    groovesharkGetStreamKeyAjaxCallback.header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_1) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/21.0.1180.89 Safari/537.1");
    aq.ajax(groovesharkGetStreamKeyAjaxCallback);
}

Example 88 with HttpEntity

use of org.apache.http.HttpEntity in project robovm by robovm.

the class AbstractHttpClient method execute.

// non-javadoc, see interface HttpClient
public <T> T execute(final HttpHost target, final HttpRequest request, final ResponseHandler<? extends T> responseHandler, final HttpContext context) throws IOException, ClientProtocolException {
    if (responseHandler == null) {
        throw new IllegalArgumentException("Response handler must not be null.");
    }
    HttpResponse response = execute(target, request, context);
    T result;
    try {
        result = responseHandler.handleResponse(response);
    } catch (Throwable t) {
        HttpEntity entity = response.getEntity();
        if (entity != null) {
            try {
                entity.consumeContent();
            } catch (Throwable t2) {
                // Log this exception. The original exception is more
                // important and will be thrown to the caller.
                this.log.warn("Error consuming content after an exception.", t2);
            }
        }
        if (t instanceof Error) {
            throw (Error) t;
        }
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        }
        if (t instanceof IOException) {
            throw (IOException) t;
        }
        throw new UndeclaredThrowableException(t);
    }
    // Handling the response was successful. Ensure that the content has
    // been fully consumed.
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        // Let this exception go to the caller.
        entity.consumeContent();
    }
    return result;
}

Example 89 with HttpEntity

use of org.apache.http.HttpEntity in project robolectric by robolectric.

the class DefaultRequestDirector method execute.

// non-javadoc, see interface ClientRequestDirector
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) throws HttpException, IOException {
    HttpRequest orig = request;
    RequestWrapper origWrapper = wrapRequest(orig);
    origWrapper.setParams(params);
    HttpRoute origRoute = determineRoute(target, origWrapper, context);
    virtualHost = (HttpHost) orig.getParams().getParameter(ClientPNames.VIRTUAL_HOST);
    RoutedRequest roureq = new RoutedRequest(origWrapper, origRoute);
    long timeout = ConnManagerParams.getTimeout(params);
    int execCount = 0;
    boolean reuse = false;
    boolean done = false;
    try {
        HttpResponse response = null;
        while (!done) {
            // In this loop, the RoutedRequest may be replaced by a
            // followup request and route. The request and route passed
            // in the method arguments will be replaced. The original
            // request is still available in 'orig'.
            RequestWrapper wrapper = roureq.getRequest();
            HttpRoute route = roureq.getRoute();
            response = null;
            // See if we have a user token bound to the execution context
            Object userToken = context.getAttribute(ClientContext.USER_TOKEN);
            // Allocate connection if needed
            if (managedConn == null) {
                ClientConnectionRequest connRequest = connManager.requestConnection(route, userToken);
                if (orig instanceof AbortableHttpRequest) {
                    ((AbortableHttpRequest) orig).setConnectionRequest(connRequest);
                }
                try {
                    managedConn = connRequest.getConnection(timeout, TimeUnit.MILLISECONDS);
                } catch (InterruptedException interrupted) {
                    InterruptedIOException iox = new InterruptedIOException();
                    iox.initCause(interrupted);
                    throw iox;
                }
                if (HttpConnectionParams.isStaleCheckingEnabled(params)) {
                    // validate connection
                    if (managedConn.isOpen()) {
                        this.log.debug("Stale connection check");
                        if (managedConn.isStale()) {
                            this.log.debug("Stale connection detected");
                            managedConn.close();
                        }
                    }
                }
            }
            if (orig instanceof AbortableHttpRequest) {
                ((AbortableHttpRequest) orig).setReleaseTrigger(managedConn);
            }
            // Reopen connection if needed
            if (!managedConn.isOpen()) {
                managedConn.open(route, context, params);
            } else {
                managedConn.setSocketTimeout(HttpConnectionParams.getSoTimeout(params));
            }
            try {
                establishRoute(route, context);
            } catch (TunnelRefusedException ex) {
                if (this.log.isDebugEnabled()) {
                    this.log.debug(ex.getMessage());
                }
                response = ex.getResponse();
                break;
            }
            // Reset headers on the request wrapper
            wrapper.resetHeaders();
            // Re-write request URI if needed
            rewriteRequestURI(wrapper, route);
            // Use virtual host if set
            target = virtualHost;
            if (target == null) {
                target = route.getTargetHost();
            }
            HttpHost proxy = route.getProxyHost();
            // Populate the execution context
            context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target);
            context.setAttribute(ExecutionContext.HTTP_PROXY_HOST, proxy);
            context.setAttribute(ExecutionContext.HTTP_CONNECTION, managedConn);
            context.setAttribute(ClientContext.TARGET_AUTH_STATE, targetAuthState);
            context.setAttribute(ClientContext.PROXY_AUTH_STATE, proxyAuthState);
            // Run request protocol interceptors
            requestExec.preProcess(wrapper, httpProcessor, context);
            boolean retrying = true;
            Exception retryReason = null;
            while (retrying) {
                // Increment total exec count (with redirects)
                execCount++;
                // Increment exec count for this particular request
                wrapper.incrementExecCount();
                if (!wrapper.isRepeatable()) {
                    this.log.debug("Cannot retry non-repeatable request");
                    if (retryReason != null) {
                        throw new NonRepeatableRequestException("Cannot retry request " + "with a non-repeatable request entity.  The cause lists the " + "reason the original request failed: " + retryReason);
                    } else {
                        throw new NonRepeatableRequestException("Cannot retry request " + "with a non-repeatable request entity.");
                    }
                }
                try {
                    if (this.log.isDebugEnabled()) {
                        this.log.debug("Attempt " + execCount + " to execute request");
                    }
                    response = requestExec.execute(wrapper, managedConn, context);
                    retrying = false;
                } catch (IOException ex) {
                    this.log.debug("Closing the connection.");
                    managedConn.close();
                    if (retryHandler.retryRequest(ex, wrapper.getExecCount(), context)) {
                        if (this.log.isInfoEnabled()) {
                            this.log.info("I/O exception (" + ex.getClass().getName() + ") caught when processing request: " + ex.getMessage());
                        }
                        if (this.log.isDebugEnabled()) {
                            this.log.debug(ex.getMessage(), ex);
                        }
                        this.log.info("Retrying request");
                        retryReason = ex;
                    } else {
                        throw ex;
                    }
                    // just re-open connection and re-try the request
                    if (!route.isTunnelled()) {
                        this.log.debug("Reopening the direct connection.");
                        managedConn.open(route, context, params);
                    } else {
                        // otherwise give up
                        this.log.debug("Proxied connection. Need to start over.");
                        retrying = false;
                    }
                }
            }
            if (response == null) {
                // Need to start over
                continue;
            }
            // Run response protocol interceptors
            response.setParams(params);
            requestExec.postProcess(response, httpProcessor, context);
            // The connection is in or can be brought to a re-usable state.
            reuse = reuseStrategy.keepAlive(response, context);
            if (reuse) {
                // Set the idle duration of this connection
                long duration = keepAliveStrategy.getKeepAliveDuration(response, context);
                managedConn.setIdleDuration(duration, TimeUnit.MILLISECONDS);
                if (this.log.isDebugEnabled()) {
                    if (duration >= 0) {
                        this.log.debug("Connection can be kept alive for " + duration + " ms");
                    } else {
                        this.log.debug("Connection can be kept alive indefinitely");
                    }
                }
            }
            RoutedRequest followup = handleResponse(roureq, response, context);
            if (followup == null) {
                done = true;
            } else {
                if (reuse) {
                    // Make sure the response body is fully consumed, if present
                    HttpEntity entity = response.getEntity();
                    if (entity != null) {
                        entity.consumeContent();
                    }
                    // entity consumed above is not an auto-release entity,
                    // need to mark the connection re-usable explicitly
                    managedConn.markReusable();
                } else {
                    managedConn.close();
                }
                // check if we can use the same connection for the followup
                if (!followup.getRoute().equals(roureq.getRoute())) {
                    releaseConnection();
                }
                roureq = followup;
            }
            if (managedConn != null && userToken == null) {
                userToken = userTokenHandler.getUserToken(context);
                context.setAttribute(ClientContext.USER_TOKEN, userToken);
                if (userToken != null) {
                    managedConn.setState(userToken);
                }
            }
        }
        // check for entity, release connection if possible
        if ((response == null) || (response.getEntity() == null) || !response.getEntity().isStreaming()) {
            // connection not needed and (assumed to be) in re-usable state
            if (reuse)
                managedConn.markReusable();
            releaseConnection();
        } else {
            // install an auto-release entity
            HttpEntity entity = response.getEntity();
            entity = new BasicManagedEntity(entity, managedConn, reuse);
            response.setEntity(entity);
        }
        return response;
    } catch (HttpException | RuntimeException | IOException ex) {
        abortConnection();
        throw ex;
    }
}

Example 90 with HttpEntity

use of org.apache.http.HttpEntity in project robolectric by robolectric.

the class DefaultRequestDirector method createTunnelToTarget.

// establishConnection
/**
   * Creates a tunnel to the target server.
   * The connection must be established to the (last) proxy.
   * A CONNECT request for tunnelling through the proxy will
   * be created and sent, the response received and checked.
   * This method does <i>not</i> update the connection with
   * information about the tunnel, that is left to the caller.
   *
   * @param route     the route to establish
   * @param context   the context for request execution
   *
   * @return  <code>true</code> if the tunnelled route is secure,
   *          <code>false</code> otherwise.
   *          The implementation here always returns <code>false</code>,
   *          but derived classes may override.
   *
   * @throws HttpException    in case of a problem
   * @throws IOException      in case of an IO problem
   */
protected boolean createTunnelToTarget(HttpRoute route, HttpContext context) throws HttpException, IOException {
    HttpHost proxy = route.getProxyHost();
    HttpHost target = route.getTargetHost();
    HttpResponse response = null;
    boolean done = false;
    while (!done) {
        done = true;
        if (!this.managedConn.isOpen()) {
            this.managedConn.open(route, context, this.params);
        }
        HttpRequest connect = createConnectRequest(route, context);
        connect.setParams(this.params);
        // Populate the execution context
        context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target);
        context.setAttribute(ExecutionContext.HTTP_PROXY_HOST, proxy);
        context.setAttribute(ExecutionContext.HTTP_CONNECTION, managedConn);
        context.setAttribute(ClientContext.TARGET_AUTH_STATE, targetAuthState);
        context.setAttribute(ClientContext.PROXY_AUTH_STATE, proxyAuthState);
        context.setAttribute(ExecutionContext.HTTP_REQUEST, connect);
        this.requestExec.preProcess(connect, this.httpProcessor, context);
        response = this.requestExec.execute(connect, this.managedConn, context);
        response.setParams(this.params);
        this.requestExec.postProcess(response, this.httpProcessor, context);
        int status = response.getStatusLine().getStatusCode();
        if (status < 200) {
            throw new HttpException("Unexpected response to CONNECT request: " + response.getStatusLine());
        }
        CredentialsProvider credsProvider = (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER);
        if (credsProvider != null && HttpClientParams.isAuthenticating(params)) {
            if (this.proxyAuthHandler.isAuthenticationRequested(response, context)) {
                this.log.debug("Proxy requested authentication");
                Map<String, Header> challenges = this.proxyAuthHandler.getChallenges(response, context);
                try {
                    processChallenges(challenges, this.proxyAuthState, this.proxyAuthHandler, response, context);
                } catch (AuthenticationException ex) {
                    if (this.log.isWarnEnabled()) {
                        this.log.warn("Authentication error: " + ex.getMessage());
                        break;
                    }
                }
                updateAuthState(this.proxyAuthState, proxy, credsProvider);
                if (this.proxyAuthState.getCredentials() != null) {
                    done = false;
                    // Retry request
                    if (this.reuseStrategy.keepAlive(response, context)) {
                        this.log.debug("Connection kept alive");
                        // Consume response content
                        HttpEntity entity = response.getEntity();
                        if (entity != null) {
                            entity.consumeContent();
                        }
                    } else {
                        this.managedConn.close();
                    }
                }
            } else {
                // Reset proxy auth scope
                this.proxyAuthState.setAuthScope(null);
            }
        }
    }
    // can't be null
    int status = response.getStatusLine().getStatusCode();
    if (status > 299) {
        // Buffer response content
        HttpEntity entity = response.getEntity();
        if (entity != null) {
            response.setEntity(new BufferedHttpEntity(entity));
        }
        this.managedConn.close();
        throw new TunnelRefusedException("CONNECT refused by proxy: " + response.getStatusLine(), response);
    }
    this.managedConn.markReusable();
    // Leave it to derived classes, consider insecure by default here.
    return false;
}