/// <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;
            }
        }