Example usage for org.apache.http.impl.client RequestWrapper setParams

List of usage examples for org.apache.http.impl.client RequestWrapper setParams

Introduction

In this page you can find the example usage for org.apache.http.impl.client RequestWrapper setParams.

Prototype

@Deprecated
    public void setParams(HttpParams httpParams) 

Source Link

Usage

From source file:org.apache.http.impl.client.StatiscicsLoggingRequestDirector.java

/**
 * Analyzes a response to check need for a followup.
 *
 * @param roureq    the request and route.
 * @param response  the response to analayze
 * @param context   the context used for the current request execution
 *
 * @return  the followup request and route if there is a followup, or
 *          <code>null</code> if the response should be returned as is
 *
 * @throws HttpException    in case of a problem
 * @throws IOException      in case of an IO problem
 *//*  w w w  .j av  a 2s .  co m*/
protected RoutedRequest handleResponse(RoutedRequest roureq, HttpResponse response, HttpContext context)
        throws HttpException, IOException {

    HttpRoute route = roureq.getRoute();
    RequestWrapper request = roureq.getRequest();

    HttpParams params = request.getParams();
    if (HttpClientParams.isRedirecting(params)
            && this.redirectStrategy.isRedirected(request, response, context)) {

        if (redirectCount >= maxRedirects) {
            throw new RedirectException("Maximum redirects (" + maxRedirects + ") exceeded");
        }
        redirectCount++;

        // Virtual host cannot be used any longer
        virtualHost = null;

        HttpUriRequest redirect = redirectStrategy.getRedirect(request, response, context);
        HttpRequest orig = request.getOriginal();
        redirect.setHeaders(orig.getAllHeaders());

        URI uri = redirect.getURI();
        if (uri.getHost() == null) {
            throw new ProtocolException("Redirect URI does not specify a valid host name: " + uri);
        }

        HttpHost newTarget = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());

        // Unset auth scope
        targetAuthState.setAuthScope(null);
        proxyAuthState.setAuthScope(null);

        // Invalidate auth states if redirecting to another host
        if (!route.getTargetHost().equals(newTarget)) {
            targetAuthState.invalidate();
            AuthScheme authScheme = proxyAuthState.getAuthScheme();
            if (authScheme != null && authScheme.isConnectionBased()) {
                proxyAuthState.invalidate();
            }
        }

        RequestWrapper wrapper = wrapRequest(redirect);
        wrapper.setParams(params);

        HttpRoute newRoute = determineRoute(newTarget, wrapper, context);
        RoutedRequest newRequest = new RoutedRequest(wrapper, newRoute);

        if (this.log.isDebugEnabled()) {
            this.log.debug("Redirecting to '" + uri + "' via " + newRoute);
        }

        return newRequest;
    }

    CredentialsProvider credsProvider = (CredentialsProvider) context
            .getAttribute(ClientContext.CREDS_PROVIDER);

    if (credsProvider != null && HttpClientParams.isAuthenticating(params)) {

        if (this.targetAuthHandler.isAuthenticationRequested(response, context)) {

            HttpHost target = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
            if (target == null) {
                target = route.getTargetHost();
            }

            this.log.debug("Target requested authentication");
            Map<String, Header> challenges = this.targetAuthHandler.getChallenges(response, context);
            try {
                processChallenges(challenges, this.targetAuthState, this.targetAuthHandler, response, context);
            } catch (AuthenticationException ex) {
                if (this.log.isWarnEnabled()) {
                    this.log.warn("Authentication error: " + ex.getMessage());
                    return null;
                }
            }
            updateAuthState(this.targetAuthState, target, credsProvider);

            if (this.targetAuthState.getCredentials() != null) {
                // Re-try the same request via the same route
                return roureq;
            } else {
                return null;
            }
        } else {
            // Reset target auth scope
            this.targetAuthState.setAuthScope(null);
        }

        if (this.proxyAuthHandler.isAuthenticationRequested(response, context)) {

            HttpHost proxy = route.getProxyHost();

            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());
                    return null;
                }
            }
            updateAuthState(this.proxyAuthState, proxy, credsProvider);

            if (this.proxyAuthState.getCredentials() != null) {
                // Re-try the same request via the same route
                return roureq;
            } else {
                return null;
            }
        } else {
            // Reset proxy auth scope
            this.proxyAuthState.setAuthScope(null);
        }
    }
    return null;
}

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

public synchronized void start() {
    try {//from   w w  w  . j av  a  2  s . c om
        if (this.log.isDebugEnabled()) {
            this.log.debug("[exchange: " + this.id + "] start execution");
        }
        this.localContext.setAttribute(ClientContext.TARGET_AUTH_STATE, this.targetAuthState);
        this.localContext.setAttribute(ClientContext.PROXY_AUTH_STATE, this.proxyAuthState);

        final HttpHost target = this.requestProducer.getTarget();
        final HttpRequest request = this.requestProducer.generateRequest();
        if (request instanceof AbortableHttpRequest) {
            ((AbortableHttpRequest) request).setReleaseTrigger(new ConnectionReleaseTrigger() {

                @Override
                public void releaseConnection() throws IOException {
                }

                @Override
                public void abortConnection() throws IOException {
                    cancel();
                }

            });
        }
        this.params = new ClientParamsStack(null, this.clientParams, request.getParams(), null);
        final RequestWrapper wrapper = wrapRequest(request);
        wrapper.setParams(this.params);
        final HttpRoute route = determineRoute(target, wrapper, this.localContext);
        this.mainRequest = new RoutedRequest(wrapper, route);
        final RequestConfig config = ParamConfig.getRequestConfig(params);
        this.localContext.setAttribute(ClientContext.REQUEST_CONFIG, config);
        this.requestContentProduced = false;
        requestConnection();
    } catch (final Exception ex) {
        failed(ex);
    }
}

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

private RoutedRequest handleRedirect() throws HttpException {
    if (this.redirectStrategy.isRedirected(this.currentRequest, this.currentResponse, this.localContext)) {

        final HttpRoute route = this.mainRequest.getRoute();
        final RequestWrapper request = this.mainRequest.getRequest();

        final int maxRedirects = this.params.getIntParameter(ClientPNames.MAX_REDIRECTS, 100);
        if (this.redirectCount >= maxRedirects) {
            throw new RedirectException("Maximum redirects (" + maxRedirects + ") exceeded");
        }//from w w  w.  jav  a 2 s.c o  m
        this.redirectCount++;

        final HttpUriRequest redirect = this.redirectStrategy.getRedirect(this.currentRequest,
                this.currentResponse, this.localContext);
        final HttpRequest orig = request.getOriginal();
        redirect.setHeaders(orig.getAllHeaders());

        final URI uri = redirect.getURI();
        if (uri.getHost() == null) {
            throw new ProtocolException("Redirect URI does not specify a valid host name: " + uri);
        }
        final HttpHost newTarget = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());

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

        final RequestWrapper newRequest = wrapRequest(redirect);
        newRequest.setParams(this.params);

        final HttpRoute newRoute = determineRoute(newTarget, newRequest, this.localContext);

        if (this.log.isDebugEnabled()) {
            this.log.debug("[exchange: " + this.id + "] Redirecting to '" + uri + "' via " + newRoute);
        }
        return new RoutedRequest(newRequest, newRoute);
    }
    return null;
}