/// <exception cref="Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); string method = request.GetRequestLine().GetMethod(); if (Sharpen.Runtime.EqualsIgnoreCase(method, "CONNECT")) { request.SetHeader(ProxyConnDirective, HTTP.ConnKeepAlive); return; } HttpClientContext clientContext = ((HttpClientContext)HttpClientContext.Adapt(context )); // Obtain the client connection (required) RouteInfo route = clientContext.GetHttpRoute(); if (route == null) { this.log.Debug("Connection route not set in the context"); return; } if (route.GetHopCount() == 1 || route.IsTunnelled()) { if (!request.ContainsHeader(HTTP.ConnDirective)) { request.AddHeader(HTTP.ConnDirective, HTTP.ConnKeepAlive); } } if (route.GetHopCount() == 2 && !route.IsTunnelled()) { if (!request.ContainsHeader(ProxyConnDirective)) { request.AddHeader(ProxyConnDirective, HTTP.ConnKeepAlive); } } }
/// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); if (request is HttpEntityEnclosingRequest) { if (this.overwrite) { request.RemoveHeaders(HTTP.TransferEncoding); request.RemoveHeaders(HTTP.ContentLen); } else { if (request.ContainsHeader(HTTP.TransferEncoding)) { throw new ProtocolException("Transfer-encoding header already present"); } if (request.ContainsHeader(HTTP.ContentLen)) { throw new ProtocolException("Content-Length header already present"); } } ProtocolVersion ver = request.GetRequestLine().GetProtocolVersion(); HttpEntity entity = ((HttpEntityEnclosingRequest)request).GetEntity(); if (entity == null) { request.AddHeader(HTTP.ContentLen, "0"); return; } // Must specify a transfer encoding or a content length if (entity.IsChunked() || entity.GetContentLength() < 0) { if (ver.LessEquals(HttpVersion.Http10)) { throw new ProtocolException("Chunked transfer encoding not allowed for " + ver); } request.AddHeader(HTTP.TransferEncoding, HTTP.ChunkCoding); } else { request.AddHeader(HTTP.ContentLen, System.Convert.ToString(entity.GetContentLength ())); } // Specify a content type if known if (entity.GetContentType() != null && !request.ContainsHeader(HTTP.ContentType)) { request.AddHeader(entity.GetContentType()); } // Specify a content encoding if known if (entity.GetContentEncoding() != null && !request.ContainsHeader(HTTP.ContentEncoding )) { request.AddHeader(entity.GetContentEncoding()); } } }
/// <summary> /// Adds the header /// <code>"Accept-Encoding: gzip,deflate"</code> /// to the request. /// </summary> /// <exception cref="Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { if (!request.ContainsHeader("Accept-Encoding")) { request.AddHeader("Accept-Encoding", "gzip,deflate"); } }
/// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); if ((request is HttpEntityEnclosingRequest) && !request.ContainsHeader(HTTP.DateHeader )) { string httpdate = DateGenerator.GetCurrentDate(); request.SetHeader(HTTP.DateHeader, httpdate); } }
/// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); string method = request.GetRequestLine().GetMethod(); if (Sharpen.Runtime.EqualsIgnoreCase(method, "CONNECT")) { return; } if (!request.ContainsHeader(HTTP.ConnDirective)) { // Default policy is to keep connection alive // whenever possible request.AddHeader(HTTP.ConnDirective, HTTP.ConnKeepAlive); } }
/// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); HttpCoreContext corecontext = HttpCoreContext.Adapt(context); ProtocolVersion ver = request.GetRequestLine().GetProtocolVersion(); string method = request.GetRequestLine().GetMethod(); if (Sharpen.Runtime.EqualsIgnoreCase(method, "CONNECT") && ver.LessEquals(HttpVersion .Http10)) { return; } if (!request.ContainsHeader(HTTP.TargetHost)) { HttpHost targethost = corecontext.GetTargetHost(); if (targethost == null) { HttpConnection conn = corecontext.GetConnection(); if (conn is HttpInetConnection) { // Populate the context with a default HTTP host based on the // inet address of the target host IPAddress address = ((HttpInetConnection)conn).GetRemoteAddress(); int port = ((HttpInetConnection)conn).GetRemotePort(); if (address != null) { targethost = new HttpHost(address.GetHostName(), port); } } if (targethost == null) { if (ver.LessEquals(HttpVersion.Http10)) { return; } else { throw new ProtocolException("Target host missing"); } } } request.AddHeader(HTTP.TargetHost, targethost.ToHostString()); } }
/// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); if (!request.ContainsHeader(HTTP.UserAgent)) { string s = null; HttpParams @params = request.GetParams(); if (@params != null) { s = (string)@params.GetParameter(CoreProtocolPNames.UserAgent); } if (s == null) { s = this.userAgent; } if (s != null) { request.AddHeader(HTTP.UserAgent, s); } } }
/// <exception cref="Org.Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); if (!request.ContainsHeader(HTTP.ExpectDirective)) { if (request is HttpEntityEnclosingRequest) { ProtocolVersion ver = request.GetRequestLine().GetProtocolVersion(); HttpEntity entity = ((HttpEntityEnclosingRequest)request).GetEntity(); // Do not send the expect header if request body is known to be empty if (entity != null && entity.GetContentLength() != 0 && !ver.LessEquals(HttpVersion .Http10)) { bool active = request.GetParams().GetBooleanParameter(CoreProtocolPNames.UseExpectContinue , this.activeByDefault); if (active) { request.AddHeader(HTTP.ExpectDirective, HTTP.ExpectContinue); } } } } }
/// <exception cref="Apache.Http.HttpException"></exception> /// <exception cref="System.IO.IOException"></exception> public virtual void Process(IHttpRequest request, HttpContext context) { Args.NotNull(request, "HTTP request"); if (!request.ContainsHeader(HTTP.ExpectDirective)) { if (request is HttpEntityEnclosingRequest) { ProtocolVersion ver = request.GetRequestLine().GetProtocolVersion(); HttpEntity entity = ((HttpEntityEnclosingRequest)request).GetEntity(); // Do not send the expect header if request body is known to be empty if (entity != null && entity.GetContentLength() != 0 && !ver.LessEquals(HttpVersion .Http10)) { HttpClientContext clientContext = ((HttpClientContext)HttpClientContext.Adapt(context )); RequestConfig config = clientContext.GetRequestConfig(); if (config.IsExpectContinueEnabled()) { request.AddHeader(HTTP.ExpectDirective, HTTP.ExpectContinue); } } } } }
/// <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; } }