public virtual object GetUserToken(HttpContext context)
        {
            HttpClientContext clientContext = ((HttpClientContext)HttpClientContext.Adapt(context
                                                                                          ));
            Principal userPrincipal   = null;
            AuthState targetAuthState = clientContext.GetTargetAuthState();

            if (targetAuthState != null)
            {
                userPrincipal = GetAuthPrincipal(targetAuthState);
                if (userPrincipal == null)
                {
                    AuthState proxyAuthState = clientContext.GetProxyAuthState();
                    userPrincipal = GetAuthPrincipal(proxyAuthState);
                }
            }
            if (userPrincipal == null)
            {
                HttpConnection conn = clientContext.GetConnection();
                if (conn.IsOpen() && conn is ManagedHttpClientConnection)
                {
                    SSLSession sslsession = ((ManagedHttpClientConnection)conn).GetSSLSession();
                    if (sslsession != null)
                    {
                        userPrincipal = sslsession.GetLocalPrincipal();
                    }
                }
            }
            return(userPrincipal);
        }
Ejemplo n.º 2
0
        /// <exception cref="System.IO.IOException"></exception>
        /// <exception cref="Apache.Http.HttpException"></exception>
        public virtual CloseableHttpResponse Execute(HttpRoute route, HttpRequestWrapper
                                                     request, HttpClientContext context, HttpExecutionAware execAware)
        {
            Args.NotNull(route, "HTTP route");
            Args.NotNull(request, "HTTP request");
            Args.NotNull(context, "HTTP context");
            IList <URI> redirectLocations = context.GetRedirectLocations();

            if (redirectLocations != null)
            {
                redirectLocations.Clear();
            }
            RequestConfig      config         = context.GetRequestConfig();
            int                maxRedirects   = config.GetMaxRedirects() > 0 ? config.GetMaxRedirects() : 50;
            HttpRoute          currentRoute   = route;
            HttpRequestWrapper currentRequest = request;

            for (int redirectCount = 0; ;)
            {
                CloseableHttpResponse response = requestExecutor.Execute(currentRoute, currentRequest
                                                                         , context, execAware);
                try
                {
                    if (config.IsRedirectsEnabled() && this.redirectStrategy.IsRedirected(currentRequest
                                                                                          , response, context))
                    {
                        if (redirectCount >= maxRedirects)
                        {
                            throw new RedirectException("Maximum redirects (" + maxRedirects + ") exceeded");
                        }
                        redirectCount++;
                        IHttpRequest redirect = this.redirectStrategy.GetRedirect(currentRequest, response
                                                                                  , context);
                        if (!redirect.HeaderIterator().HasNext())
                        {
                            IHttpRequest original = request.GetOriginal();
                            redirect.SetHeaders(original.GetAllHeaders());
                        }
                        currentRequest = HttpRequestWrapper.Wrap(redirect);
                        if (currentRequest is HttpEntityEnclosingRequest)
                        {
                            Proxies.EnhanceEntity((HttpEntityEnclosingRequest)currentRequest);
                        }
                        URI      uri       = currentRequest.GetURI();
                        HttpHost newTarget = URIUtils.ExtractHost(uri);
                        if (newTarget == null)
                        {
                            throw new ProtocolException("Redirect URI does not specify a valid host name: " +
                                                        uri);
                        }
                        // Reset virtual host and auth states if redirecting to another host
                        if (!currentRoute.GetTargetHost().Equals(newTarget))
                        {
                            AuthState targetAuthState = context.GetTargetAuthState();
                            if (targetAuthState != null)
                            {
                                this.log.Debug("Resetting target auth state");
                                targetAuthState.Reset();
                            }
                            AuthState proxyAuthState = context.GetProxyAuthState();
                            if (proxyAuthState != null)
                            {
                                AuthScheme authScheme = proxyAuthState.GetAuthScheme();
                                if (authScheme != null && authScheme.IsConnectionBased())
                                {
                                    this.log.Debug("Resetting proxy auth state");
                                    proxyAuthState.Reset();
                                }
                            }
                        }
                        currentRoute = this.routePlanner.DetermineRoute(newTarget, currentRequest, context
                                                                        );
                        if (this.log.IsDebugEnabled())
                        {
                            this.log.Debug("Redirecting to '" + uri + "' via " + currentRoute);
                        }
                        EntityUtils.Consume(response.GetEntity());
                        response.Close();
                    }
                    else
                    {
                        return(response);
                    }
                }
                catch (RuntimeException ex)
                {
                    response.Close();
                    throw;
                }
                catch (IOException ex)
                {
                    response.Close();
                    throw;
                }
                catch (HttpException ex)
                {
                    // Protocol exception related to a direct.
                    // The underlying connection may still be salvaged.
                    try
                    {
                        EntityUtils.Consume(response.GetEntity());
                    }
                    catch (IOException ioex)
                    {
                        this.log.Debug("I/O error while releasing connection", ioex);
                    }
                    finally
                    {
                        response.Close();
                    }
                    throw;
                }
            }
        }
Ejemplo n.º 3
0
        /// <exception cref="System.IO.IOException"></exception>
        /// <exception cref="Apache.Http.HttpException"></exception>
        public virtual CloseableHttpResponse Execute(HttpRoute route, HttpRequestWrapper
                                                     request, HttpClientContext context, HttpExecutionAware execAware)
        {
            Args.NotNull(route, "HTTP route");
            Args.NotNull(request, "HTTP request");
            Args.NotNull(context, "HTTP context");
            AuthState targetAuthState = context.GetTargetAuthState();

            if (targetAuthState == null)
            {
                targetAuthState = new AuthState();
                context.SetAttribute(HttpClientContext.TargetAuthState, targetAuthState);
            }
            AuthState proxyAuthState = context.GetProxyAuthState();

            if (proxyAuthState == null)
            {
                proxyAuthState = new AuthState();
                context.SetAttribute(HttpClientContext.ProxyAuthState, proxyAuthState);
            }
            if (request is HttpEntityEnclosingRequest)
            {
                Proxies.EnhanceEntity((HttpEntityEnclosingRequest)request);
            }
            object            userToken   = context.GetUserToken();
            ConnectionRequest connRequest = connManager.RequestConnection(route, userToken);

            if (execAware != null)
            {
                if (execAware.IsAborted())
                {
                    connRequest.Cancel();
                    throw new RequestAbortedException("Request aborted");
                }
                else
                {
                    execAware.SetCancellable(connRequest);
                }
            }
            RequestConfig        config = context.GetRequestConfig();
            HttpClientConnection managedConn;

            try
            {
                int timeout = config.GetConnectionRequestTimeout();
                managedConn = connRequest.Get(timeout > 0 ? timeout : 0, TimeUnit.Milliseconds);
            }
            catch (Exception interrupted)
            {
                Sharpen.Thread.CurrentThread().Interrupt();
                throw new RequestAbortedException("Request aborted", interrupted);
            }
            catch (ExecutionException ex)
            {
                Exception cause = ex.InnerException;
                if (cause == null)
                {
                    cause = ex;
                }
                throw new RequestAbortedException("Request execution failed", cause);
            }
            context.SetAttribute(HttpClientContext.HttpConnection, managedConn);
            if (config.IsStaleConnectionCheckEnabled())
            {
                // validate connection
                if (managedConn.IsOpen())
                {
                    this.log.Debug("Stale connection check");
                    if (managedConn.IsStale())
                    {
                        this.log.Debug("Stale connection detected");
                        managedConn.Close();
                    }
                }
            }
            ConnectionHolder connHolder = new ConnectionHolder(this.log, this.connManager, managedConn
                                                               );

            try
            {
                if (execAware != null)
                {
                    execAware.SetCancellable(connHolder);
                }
                HttpResponse response;
                for (int execCount = 1; ; execCount++)
                {
                    if (execCount > 1 && !Proxies.IsRepeatable(request))
                    {
                        throw new NonRepeatableRequestException("Cannot retry request " + "with a non-repeatable request entity."
                                                                );
                    }
                    if (execAware != null && execAware.IsAborted())
                    {
                        throw new RequestAbortedException("Request aborted");
                    }
                    if (!managedConn.IsOpen())
                    {
                        this.log.Debug("Opening connection " + route);
                        try
                        {
                            EstablishRoute(proxyAuthState, managedConn, route, request, context);
                        }
                        catch (TunnelRefusedException ex)
                        {
                            if (this.log.IsDebugEnabled())
                            {
                                this.log.Debug(ex.Message);
                            }
                            response = ex.GetResponse();
                            break;
                        }
                    }
                    int timeout = config.GetSocketTimeout();
                    if (timeout >= 0)
                    {
                        managedConn.SetSocketTimeout(timeout);
                    }
                    if (execAware != null && execAware.IsAborted())
                    {
                        throw new RequestAbortedException("Request aborted");
                    }
                    if (this.log.IsDebugEnabled())
                    {
                        this.log.Debug("Executing request " + request.GetRequestLine());
                    }
                    if (!request.ContainsHeader(AUTH.WwwAuthResp))
                    {
                        if (this.log.IsDebugEnabled())
                        {
                            this.log.Debug("Target auth state: " + targetAuthState.GetState());
                        }
                        this.authenticator.GenerateAuthResponse(request, targetAuthState, context);
                    }
                    if (!request.ContainsHeader(AUTH.ProxyAuthResp) && !route.IsTunnelled())
                    {
                        if (this.log.IsDebugEnabled())
                        {
                            this.log.Debug("Proxy auth state: " + proxyAuthState.GetState());
                        }
                        this.authenticator.GenerateAuthResponse(request, proxyAuthState, context);
                    }
                    response = requestExecutor.Execute(request, managedConn, context);
                    // The connection is in or can be brought to a re-usable state.
                    if (reuseStrategy.KeepAlive(response, context))
                    {
                        // Set the idle duration of this connection
                        long duration = keepAliveStrategy.GetKeepAliveDuration(response, context);
                        if (this.log.IsDebugEnabled())
                        {
                            string s;
                            if (duration > 0)
                            {
                                s = "for " + duration + " " + TimeUnit.Milliseconds;
                            }
                            else
                            {
                                s = "indefinitely";
                            }
                            this.log.Debug("Connection can be kept alive " + s);
                        }
                        connHolder.SetValidFor(duration, TimeUnit.Milliseconds);
                        connHolder.MarkReusable();
                    }
                    else
                    {
                        connHolder.MarkNonReusable();
                    }
                    if (NeedAuthentication(targetAuthState, proxyAuthState, route, response, context))
                    {
                        // Make sure the response body is fully consumed, if present
                        HttpEntity entity = response.GetEntity();
                        if (connHolder.IsReusable())
                        {
                            EntityUtils.Consume(entity);
                        }
                        else
                        {
                            managedConn.Close();
                            if (proxyAuthState.GetState() == AuthProtocolState.Success && proxyAuthState.GetAuthScheme
                                    () != null && proxyAuthState.GetAuthScheme().IsConnectionBased())
                            {
                                this.log.Debug("Resetting proxy auth state");
                                proxyAuthState.Reset();
                            }
                            if (targetAuthState.GetState() == AuthProtocolState.Success && targetAuthState.GetAuthScheme
                                    () != null && targetAuthState.GetAuthScheme().IsConnectionBased())
                            {
                                this.log.Debug("Resetting target auth state");
                                targetAuthState.Reset();
                            }
                        }
                        // discard previous auth headers
                        IHttpRequest original = request.GetOriginal();
                        if (!original.ContainsHeader(AUTH.WwwAuthResp))
                        {
                            request.RemoveHeaders(AUTH.WwwAuthResp);
                        }
                        if (!original.ContainsHeader(AUTH.ProxyAuthResp))
                        {
                            request.RemoveHeaders(AUTH.ProxyAuthResp);
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                if (userToken == null)
                {
                    userToken = userTokenHandler.GetUserToken(context);
                    context.SetAttribute(HttpClientContext.UserToken, userToken);
                }
                if (userToken != null)
                {
                    connHolder.SetState(userToken);
                }
                // check for entity, release connection if possible
                HttpEntity entity_1 = response.GetEntity();
                if (entity_1 == null || !entity_1.IsStreaming())
                {
                    // connection not needed and (assumed to be) in re-usable state
                    connHolder.ReleaseConnection();
                    return(Proxies.EnhanceResponse(response, null));
                }
                else
                {
                    return(Proxies.EnhanceResponse(response, connHolder));
                }
            }
            catch (ConnectionShutdownException ex)
            {
                ThreadInterruptedException ioex = new ThreadInterruptedException("Connection has been shut down"
                                                                                 );
                Sharpen.Extensions.InitCause(ioex, ex);
                throw ioex;
            }
            catch (HttpException ex)
            {
                connHolder.AbortConnection();
                throw;
            }
            catch (IOException ex)
            {
                connHolder.AbortConnection();
                throw;
            }
            catch (RuntimeException ex)
            {
                connHolder.AbortConnection();
                throw;
            }
        }