throws HttpException, IOException { HttpHost proxy = route.getProxyHost(); HttpHost target = route.getTargetHost(); HttpResponse response = null; connect.setParams(this.params); 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()); if (this.reuseStrategy.keepAlive(response, context)) { this.log.debug("Connection kept alive"); int status = response.getStatusLine().getStatusCode(); // can't be null
@Override protected HttpRequestExecutor createRequestExecutor() { return new HttpRequestExecutor(); }
HttpResponse response = doSendRequest(request, conn, context); if (response == null) { response = doReceiveResponse(request, conn, context); conn.close(); throw ex; } catch (HttpException ex) { conn.close(); throw ex; } catch (RuntimeException ex) { conn.close(); throw ex;
HttpRoute origRoute = determineRoute(target, origWrapper, context); virtualHost = (HttpHost) orig.getParams().getParameter( ClientPNames.VIRTUAL_HOST); target = route.getTargetHost(); HttpHost proxy = route.getProxyHost(); requestExec.preProcess(wrapper, httpProcessor, context); this.log.debug("Attempt " + execCount + " to execute request"); response = requestExec.execute(wrapper, managedConn, context); retrying = false; response.setParams(params); requestExec.postProcess(response, httpProcessor, context); reuse = reuseStrategy.keepAlive(response, context); if (reuse) { if (reuse) { if ((response == null) || (response.getEntity() == null) || !response.getEntity().isStreaming()) {
final HttpRoute route = new HttpRoute( host, this.requestConfig.getLocalAddress(), context.setAttribute(HttpClientContext.REQUEST_CONFIG, this.requestConfig); this.requestExec.preProcess(connect, this.httpProcessor, context); response = this.requestExec.execute(connect, conn, context); final int status = response.getStatusLine().getStatusCode(); if (status < 200) { throw new HttpException("Unexpected response to CONNECT request: " + response.getStatusLine()); this.proxyAuthStrategy, this.proxyAuthState, context)) { if (this.reuseStrategy.keepAlive(response, context)) { final HttpEntity entity = response.getEntity(); EntityUtils.consume(entity); } else { connect.removeHeaders(AUTH.PROXY_AUTH_RESP); } else { break; final int status = response.getStatusLine().getStatusCode();
final int timeout = config.getConnectTimeout(); final HttpHost target = route.getTargetHost(); final HttpHost proxy = route.getProxyHost(); HttpResponse response = null; final String authority = target.toHostString(); final HttpRequest connect = new BasicHttpRequest("CONNECT", authority, request.getProtocolVersion()); this.requestExecutor.preProcess(connect, this.proxyHttpProcessor, context); if (!managedConn.isOpen()) { this.connManager.connect( managedConn, connect.removeHeaders(AUTH.PROXY_AUTH_RESP); this.authenticator.generateAuthResponse(connect, proxyAuthState, context); response = this.requestExecutor.execute(connect, managedConn, context); this.proxyAuthStrategy, proxyAuthState, context)) { if (this.reuseStrategy.keepAlive(response, context)) { this.log.debug("Connection kept alive"); final int status = response.getStatusLine().getStatusCode();
response = conn.receiveResponseHeader(); if (canResponseHaveBody(request, response)) { conn.receiveResponseEntity(response); statuscode = response.getStatusLine().getStatusCode();
context.setAttribute(ExecutionContext.HTTP_REQ_SENT, Boolean.FALSE); conn.sendRequestHeader(request); if (request instanceof HttpEntityEnclosingRequest) { request.getRequestLine().getProtocolVersion(); if (((HttpEntityEnclosingRequest) request).expectContinue() && !ver.lessEquals(HttpVersion.HTTP_1_0)) { conn.flush(); int tms = request.getParams().getIntParameter( CoreProtocolPNames.WAIT_FOR_CONTINUE, 2000); if (conn.isResponseAvailable(tms)) { response = conn.receiveResponseHeader(); if (canResponseHaveBody(request, response)) { conn.receiveResponseEntity(response); int status = response.getStatusLine().getStatusCode(); if (status < 200) { if (status != HttpStatus.SC_CONTINUE) { throw new ProtocolException( "Unexpected response: " + response.getStatusLine());
DefaultHttpClientConnection conn = new DefaultHttpClientConnection(); if ("https".equals(targetHost.getSchemeName())) { SocketFactory socketFactory = SSLSocketFactory.getDefault(); socket = socketFactory.createSocket(hostname, port); this.httpexecutor.preProcess(req, this.httpProcessor, this.context); response = this.httpexecutor.execute(req, conn, this.context); this.httpexecutor.postProcess(response, this.httpProcessor, this.context); if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) { stats.incSuccessCount(); } else { HttpEntity entity = response.getEntity(); String charset = EntityUtils.getContentCharSet(entity); if (charset == null) { if (!keepalive || !this.connstrategy.keepAlive(response, this.context)) { conn.close(); Header header = response.getFirstHeader("Server"); if (header != null) { stats.setServerName(header.getValue());
throws HttpException, IOException { HttpHost proxy = route.getProxyHost(); HttpHost target = route.getTargetHost(); HttpResponse response = null; connect.addHeader(HTTP.USER_AGENT, agent); connect.addHeader(HTTP.TARGET_HOST, target.toHostString()); response = requestExec.execute(connect, this.managedConn, context); int status = response.getStatusLine().getStatusCode(); if (status < 200) { throw new HttpException("Unexpected response to CONNECT request: " + response.getStatusLine()); if (this.reuseStrategy.keepAlive(response, context)) { this.log.debug("Connection kept alive"); HttpEntity entity = response.getEntity(); if (entity != null) { entity.consumeContent(); int status = response.getStatusLine().getStatusCode();
new RequestUserAgent()}); HttpRequestExecutor httpexecutor = new HttpRequestExecutor(); ConnectionReuseStrategy connStrategy = new DefaultConnectionReuseStrategy(); HttpHost proxy = new HttpHost("squid", 8080); try { if (!conn.isOpen()) { Socket socket = new Socket(proxy.getHostName(), proxy.getPort()); conn.bind(socket, params); context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target); httpexecutor.preProcess(request, httpproc, context); HttpResponse response = httpexecutor.execute(request, conn, context); httpexecutor.postProcess(response, httpproc, context); if (!connStrategy.keepAlive(response, context)) { conn.close(); } else {
final HttpClientContext context, final HttpExecutionAware execAware) throws IOException, HttpException { Args.notNull(route, "HTTP route"); Args.notNull(request, "HTTP request"); Args.notNull(context, "HTTP context"); if (!managedConn.isOpen()) { final int timeout = config.getConnectTimeout(); this.connManager.connect( managedConn.setSocketTimeout(timeout); final URI uri = ((HttpUriRequest) original).getURI(); if (uri.isAbsolute()) { target = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()); target = route.getTargetHost(); final HttpResponse response = requestExecutor.execute(request, managedConn, context); httpProcessor.process(response, context); if (reuseStrategy.keepAlive(response, context)) { final HttpEntity entity = response.getEntity(); if (entity == null || !entity.isStreaming()) {
response.setStatusCode(HttpStatus.SC_NOT_FOUND); response.setReasonPhrase(e.getMessage()); return; response.setStatusCode(HttpStatus.SC_NOT_FOUND); response.setReasonPhrase(e.getMessage()); logger.error(ExceptionUtil.exception_details(e)); System.out.println(">> Request URI: " + request.getRequestLine().getUri()); System.out.println("<< Response: " + response.getStatusLine()); final boolean keepalive = this.connStrategy.keepAlive(response, context); context.setAttribute(ElementalReverseProxy.HTTP_CONN_KEEPALIVE, new Boolean(keepalive)); return; targetLogger.logRequest(targetRequest); this.httpexecutor.preProcess(targetRequest, this.httpproc, context); final HttpResponse targetResponse1 = this.httpexecutor.execute(targetRequest, conn, context); targetLogger.logResponse(targetResponse1); this.httpexecutor.postProcess(response, this.httpproc, context); System.out.println("<< Response: " + response.getStatusLine());
HttpRequestExecutor httpexecutor = new HttpRequestExecutor(); HttpHost host = new HttpHost(host_string, port); HttpRoute route = new HttpRoute(host, null, false); httpexecutor.preProcess(request, httpproc, context); response = httpexecutor.execute(request, conn, context); response.setParams(params); httpexecutor.postProcess(response, httpproc, context); String ret = EntityUtils.toString(response.getEntity()); System.out.println("<< Response: " + response.getStatusLine()); System.out.println(ret); System.out.println("=============="); if (!connStrategy.keepAlive(response, context)) { conn.close(); } else {
target = route.getTargetHost(); HttpHost proxy = route.getProxyHost(); requestExec.preProcess(wrapper, httpProcessor, context); this.log.debug("Attempt " + execCount + " to execute request"); response = requestExec.execute(wrapper, managedConn, context); retrying = false; if (route.getHopCount() == 1) { this.log.debug("Reopening the direct connection."); managedConn.open(route, context, params); response.setParams(params); requestExec.postProcess(response, httpProcessor, context); reuse = reuseStrategy.keepAlive(response, context); if(reuse) { this.log.debug("Connection kept alive"); if ((response == null) || (response.getEntity() == null) || !response.getEntity().isStreaming()) {
@Override protected HttpResponse doReceiveResponse(final HttpRequest request, final HttpClientConnection conn, final HttpContext context) throws HttpException, IOException { final HttpResponse response = super.doReceiveResponse(request, conn, context); synchronized(listener) { listener.log(TranscriptListener.Type.response, response.getStatusLine().toString()); for(Header header : response.getAllHeaders()) { listener.log(TranscriptListener.Type.response, header.toString()); } } return response; } }
private void get(final HttpResponseHandler responseHandler, final String... paths) throws IOException, HttpException { ConnectionReuseStrategy connStrategy = new DefaultConnectionReuseStrategy(); try (DefaultBHttpClientConnection conn = new DefaultBHttpClientConnection(8 * 1024)) { for (String path : paths) { if (!conn.isOpen()) { Socket socket = new Socket(httpHost.getHostName(), httpHost.getPort()); conn.bind(socket); } BasicHttpRequest request = new BasicHttpRequest("GET", path); System.out.println(">> Request IRI: " + request.getRequestLine().getUri()); httpExecutor.preProcess(request, httpProcessor, httpContext); HttpResponse response = httpExecutor.execute(request, conn, httpContext); httpExecutor.postProcess(response, httpProcessor, httpContext); responseHandler.handle(response); if (!connStrategy.keepAlive(response, httpContext)) { conn.close(); } else { System.out.println("Connection kept alive..."); } } } }
@Override protected HttpResponse doSendRequest(final HttpRequest request, final HttpClientConnection conn, final HttpContext context) throws IOException, HttpException { synchronized(listener) { listener.log(TranscriptListener.Type.request, request.getRequestLine().toString()); for(Header header : request.getAllHeaders()) { switch(header.getName()) { case HttpHeaders.AUTHORIZATION: case "X-Auth-Key": case "X-Auth-Token": listener.log(TranscriptListener.Type.request, String.format("%s: %s", header.getName(), StringUtils.repeat("*", Integer.min(8, StringUtils.length(header.getValue()))))); break; default: listener.log(TranscriptListener.Type.request, header.toString()); break; } } } return super.doSendRequest(request, conn, context); }
@Override public HttpResponse execute(final HttpRequest request, final HttpClientConnection conn, final HttpContext context) throws IOException, HttpException { if(!request.containsHeader(HttpHeaders.USER_AGENT)) { request.addHeader(new BasicHeader(HttpHeaders.USER_AGENT, useragentProvider.get())); } return super.execute(request, conn, context); }
@Override public HttpResponse execute(final HttpRequest request, final HttpClientConnection conn, final HttpContext context) throws IOException, HttpException { for(Header h : headers) { request.addHeader(new BasicHeader(h.getName(), h.getValue())); } return super.execute(request, conn, context); } }