List of usage examples for org.apache.http.conn ClientConnectionRequest getConnection
ManagedClientConnection getConnection(long timeout, TimeUnit tunit) throws InterruptedException, ConnectionPoolTimeoutException;
From source file:httpclient.conn.ManagerConnectDirect.java
/** * Main entry point to this example.//from w w w . j a v a2 s . c o m * * @param args ignored */ public final static void main(String[] args) throws Exception { final HttpHost target = new HttpHost("jakarta.apache.org", 80, "http"); setup(); // some general setup ClientConnectionManager clcm = createManager(); HttpRequest req = createRequest(target); HttpContext ctx = createContext(); System.out.println("preparing route to " + target); HttpRoute route = new HttpRoute(target, null, supportedSchemes.getScheme(target).isLayered()); System.out.println("requesting connection for " + route); ClientConnectionRequest connRequest = clcm.requestConnection(route, null); ManagedClientConnection conn = connRequest.getConnection(0, null); try { System.out.println("opening connection"); conn.open(route, ctx, getParams()); System.out.println("sending request"); conn.sendRequestHeader(req); // there is no request entity conn.flush(); System.out.println("receiving response header"); HttpResponse rsp = conn.receiveResponseHeader(); System.out.println("----------------------------------------"); System.out.println(rsp.getStatusLine()); Header[] headers = rsp.getAllHeaders(); for (int i = 0; i < headers.length; i++) { System.out.println(headers[i]); } System.out.println("----------------------------------------"); System.out.println("closing connection"); conn.close(); } finally { if (conn.isOpen()) { System.out.println("shutting down connection"); try { conn.shutdown(); } catch (Exception x) { System.out.println("problem during shutdown"); x.printStackTrace(System.out); } } System.out.println("releasing connection"); clcm.releaseConnection(conn, -1, null); } }
From source file:httpclient.conn.ManagerConnectProxy.java
/** * Main entry point to this example./*ww w . j av a 2 s. co m*/ * * @param args ignored */ public final static void main(String[] args) throws Exception { // make sure to use a proxy that supports CONNECT final HttpHost target = new HttpHost("issues.apache.org", 443, "https"); final HttpHost proxy = new HttpHost("127.0.0.1", 8666, "http"); setup(); // some general setup ClientConnectionManager clcm = createManager(); HttpRequest req = createRequest(target); HttpContext ctx = createContext(); System.out.println("preparing route to " + target + " via " + proxy); HttpRoute route = new HttpRoute(target, null, proxy, supportedSchemes.getScheme(target).isLayered()); System.out.println("requesting connection for " + route); ClientConnectionRequest connRequest = clcm.requestConnection(route, null); ManagedClientConnection conn = connRequest.getConnection(0, null); try { System.out.println("opening connection"); conn.open(route, ctx, getParams()); HttpRequest connect = createConnect(target); System.out.println("opening tunnel to " + target); conn.sendRequestHeader(connect); // there is no request entity conn.flush(); System.out.println("receiving confirmation for tunnel"); HttpResponse connected = conn.receiveResponseHeader(); System.out.println("----------------------------------------"); printResponseHeader(connected); System.out.println("----------------------------------------"); int status = connected.getStatusLine().getStatusCode(); if ((status < 200) || (status > 299)) { System.out.println("unexpected status code " + status); System.exit(1); } System.out.println("receiving response body (ignored)"); conn.receiveResponseEntity(connected); conn.tunnelTarget(false, getParams()); System.out.println("layering secure connection"); conn.layerProtocol(ctx, getParams()); // finally we have the secure connection and can send the request System.out.println("sending request"); conn.sendRequestHeader(req); // there is no request entity conn.flush(); System.out.println("receiving response header"); HttpResponse rsp = conn.receiveResponseHeader(); System.out.println("----------------------------------------"); printResponseHeader(rsp); System.out.println("----------------------------------------"); System.out.println("closing connection"); conn.close(); } finally { if (conn.isOpen()) { System.out.println("shutting down connection"); try { conn.shutdown(); } catch (Exception x) { System.out.println("problem during shutdown"); x.printStackTrace(System.out); } } System.out.println("releasing connection"); clcm.releaseConnection(conn, -1, null); } }
From source file:gr.wavesoft.webng.io.web.WebStreams.java
public static HttpResponse httpGET(URL url, HashMap<String, String> headers) throws IOException { try {//from www . ja v a 2s . c om // WebRequest connection ClientConnectionRequest connRequest = connectionManager.requestConnection( new HttpRoute(new HttpHost(url.getHost(), url.getPort(), url.getProtocol())), null); ManagedClientConnection conn = connRequest.getConnection(10, TimeUnit.SECONDS); try { // Prepare request BasicHttpRequest request = new BasicHttpRequest("GET", url.getPath()); // Setup headers if (headers != null) { for (String k : headers.keySet()) { request.addHeader(k, headers.get(k)); } } // Send request conn.sendRequestHeader(request); // Fetch response HttpResponse response = conn.receiveResponseHeader(); conn.receiveResponseEntity(response); HttpEntity entity = response.getEntity(); if (entity != null) { BasicManagedEntity managedEntity = new BasicManagedEntity(entity, conn, true); // Replace entity response.setEntity(managedEntity); } // Do something useful with the response // The connection will be released automatically // as soon as the response content has been consumed return response; } catch (IOException ex) { // Abort connection upon an I/O error. conn.abortConnection(); throw ex; } } catch (HttpException ex) { throw new IOException("HTTP Exception occured", ex); } catch (InterruptedException ex) { throw new IOException("InterruptedException", ex); } catch (ConnectionPoolTimeoutException ex) { throw new IOException("ConnectionPoolTimeoutException", ex); } }
From source file:org.deviceconnect.message.intent.impl.client.IntentRequestDirector.java
@Override public HttpResponse execute(final HttpHost target, final HttpRequest request, final HttpContext context) throws HttpException, IOException { RequestWrapper origWrapper = new RequestWrapper(request); HttpRoute origRoute = determineRoute(target, origWrapper, context); Object userToken = context.getAttribute(ClientContext.USER_TOKEN); long timeout = HttpConnectionParams.getConnectionTimeout(params); ClientConnectionRequest connRequest = connManager.requestConnection(origRoute, userToken); ManagedClientConnection managedConn; try {/*from w w w.ja v a 2 s .c o m*/ managedConn = connRequest.getConnection(timeout, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new IOException(e); } if (request.getFirstHeader(HttpHeaders.HOST) == null) { request.setHeader(HttpHeaders.HOST, "org.deviceconnect.manager/.DConnectBroadcastReceiver"); } // requestExec.preProcess(request, httpProcessor, context); HttpResponse response = requestExec.execute(request, managedConn, context); // requestExec.postProcess(response, httpProcessor, context); return response; }
From source file:com.grendelscan.commons.http.apache_overrides.client.CustomClientRequestDirector.java
@Override public HttpResponse execute(HttpHost originalTarget, final HttpRequest request, HttpContext context) throws HttpException, IOException { HttpHost target = originalTarget;/* w ww . j a v a 2 s .c o m*/ final HttpRoute route = determineRoute(target, request, context); virtualHost = (HttpHost) request.getParams().getParameter(ClientPNames.VIRTUAL_HOST); long timeout = ConnManagerParams.getTimeout(params); try { HttpResponse response = null; // See if we have a user token bound to the execution context Object userToken = context.getAttribute(ClientContext.USER_TOKEN); // Allocate connection if needed if (managedConn == null) { ClientConnectionRequest connRequest = connManager.requestConnection(route, userToken); if (request instanceof AbortableHttpRequest) { ((AbortableHttpRequest) request).setConnectionRequest(connRequest); } try { managedConn = connRequest.getConnection(timeout, TimeUnit.MILLISECONDS); } catch (InterruptedException interrupted) { InterruptedIOException iox = new InterruptedIOException(); iox.initCause(interrupted); throw iox; } if (HttpConnectionParams.isStaleCheckingEnabled(params)) { // validate connection if (managedConn.isOpen()) { LOGGER.debug("Stale connection check"); if (managedConn.isStale()) { LOGGER.debug("Stale connection detected"); managedConn.close(); } } } } if (request instanceof AbortableHttpRequest) { ((AbortableHttpRequest) request).setReleaseTrigger(managedConn); } // Reopen connection if needed if (!managedConn.isOpen()) { managedConn.open(route, context, params); } else { managedConn.setSocketTimeout(HttpConnectionParams.getSoTimeout(params)); } try { establishRoute(route, context); } catch (TunnelRefusedException ex) { LOGGER.debug(ex.getMessage()); response = ex.getResponse(); } // Use virtual host if set target = virtualHost; if (target == null) { target = route.getTargetHost(); } HttpHost proxy = route.getProxyHost(); // Populate the execution context context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target); context.setAttribute(ExecutionContext.HTTP_PROXY_HOST, proxy); context.setAttribute(ExecutionContext.HTTP_CONNECTION, managedConn); context.setAttribute(ClientContext.TARGET_AUTH_STATE, targetAuthState); context.setAttribute(ClientContext.PROXY_AUTH_STATE, proxyAuthState); // Run request protocol interceptors requestExec.preProcess(request, httpProcessor, context); try { response = requestExec.execute(request, managedConn, context); } catch (IOException ex) { LOGGER.debug("Closing connection after request failure."); managedConn.close(); throw ex; } if (response == null) { return null; } // Run response protocol interceptors response.setParams(params); requestExec.postProcess(response, httpProcessor, context); // The connection is in or can be brought to a re-usable state. boolean reuse = reuseStrategy.keepAlive(response, context); if (reuse) { // Set the idle duration of this connection long duration = keepAliveStrategy.getKeepAliveDuration(response, context); managedConn.setIdleDuration(duration, TimeUnit.MILLISECONDS); if (duration >= 0) { LOGGER.trace("Connection can be kept alive for " + duration + " ms"); } else { LOGGER.trace("Connection can be kept alive indefinitely"); } } if ((managedConn != null) && (userToken == null)) { userToken = userTokenHandler.getUserToken(context); context.setAttribute(ClientContext.USER_TOKEN, userToken); if (userToken != null) { managedConn.setState(userToken); } } // check for entity, release connection if possible if ((response.getEntity() == null) || !response.getEntity().isStreaming()) { // connection not needed and (assumed to be) in re-usable state if (reuse) { managedConn.markReusable(); } releaseConnection(); } else { // install an auto-release entity HttpEntity entity = response.getEntity(); entity = new BasicManagedEntity(entity, managedConn, reuse); response.setEntity(entity); } return response; } catch (HttpException ex) { abortConnection(); throw ex; } catch (IOException ex) { abortConnection(); throw ex; } catch (RuntimeException ex) { abortConnection(); throw ex; } }
From source file:com.xtremelabs.robolectric.tester.org.apache.http.impl.client.DefaultRequestDirector.java
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) throws HttpException, IOException { HttpRequest orig = request;//from w w w. java 2 s. c om RequestWrapper origWrapper = wrapRequest(orig); origWrapper.setParams(params); HttpRoute origRoute = determineRoute(target, origWrapper, context); virtualHost = (HttpHost) orig.getParams().getParameter(ClientPNames.VIRTUAL_HOST); RoutedRequest roureq = new RoutedRequest(origWrapper, origRoute); long timeout = ConnManagerParams.getTimeout(params); int execCount = 0; boolean reuse = false; boolean done = false; try { HttpResponse response = null; while (!done) { // In this loop, the RoutedRequest may be replaced by a // followup request and route. The request and route passed // in the method arguments will be replaced. The original // request is still available in 'orig'. RequestWrapper wrapper = roureq.getRequest(); HttpRoute route = roureq.getRoute(); response = null; // See if we have a user token bound to the execution context Object userToken = context.getAttribute(ClientContext.USER_TOKEN); // Allocate connection if needed if (managedConn == null) { ClientConnectionRequest connRequest = connManager.requestConnection(route, userToken); if (orig instanceof AbortableHttpRequest) { ((AbortableHttpRequest) orig).setConnectionRequest(connRequest); } try { managedConn = connRequest.getConnection(timeout, TimeUnit.MILLISECONDS); } catch (InterruptedException interrupted) { InterruptedIOException iox = new InterruptedIOException(); iox.initCause(interrupted); throw iox; } if (HttpConnectionParams.isStaleCheckingEnabled(params)) { // validate connection if (managedConn.isOpen()) { this.log.debug("Stale connection check"); if (managedConn.isStale()) { this.log.debug("Stale connection detected"); managedConn.close(); } } } } if (orig instanceof AbortableHttpRequest) { ((AbortableHttpRequest) orig).setReleaseTrigger(managedConn); } // Reopen connection if needed if (!managedConn.isOpen()) { managedConn.open(route, context, params); } else { managedConn.setSocketTimeout(HttpConnectionParams.getSoTimeout(params)); } try { establishRoute(route, context); } catch (TunnelRefusedException ex) { if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage()); } response = ex.getResponse(); break; } // Reset headers on the request wrapper wrapper.resetHeaders(); // Re-write request URI if needed rewriteRequestURI(wrapper, route); // Use virtual host if set target = virtualHost; if (target == null) { target = route.getTargetHost(); } HttpHost proxy = route.getProxyHost(); // Populate the execution context context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target); context.setAttribute(ExecutionContext.HTTP_PROXY_HOST, proxy); context.setAttribute(ExecutionContext.HTTP_CONNECTION, managedConn); context.setAttribute(ClientContext.TARGET_AUTH_STATE, targetAuthState); context.setAttribute(ClientContext.PROXY_AUTH_STATE, proxyAuthState); // Run request protocol interceptors requestExec.preProcess(wrapper, httpProcessor, context); boolean retrying = true; Exception retryReason = null; while (retrying) { // Increment total exec count (with redirects) execCount++; // Increment exec count for this particular request wrapper.incrementExecCount(); if (!wrapper.isRepeatable()) { this.log.debug("Cannot retry non-repeatable request"); if (retryReason != null) { throw new NonRepeatableRequestException("Cannot retry request " + "with a non-repeatable request entity. The cause lists the " + "reason the original request failed: " + retryReason); } else { throw new NonRepeatableRequestException( "Cannot retry request " + "with a non-repeatable request entity."); } } try { if (this.log.isDebugEnabled()) { this.log.debug("Attempt " + execCount + " to execute request"); } response = requestExec.execute(wrapper, managedConn, context); retrying = false; } catch (IOException ex) { this.log.debug("Closing the connection."); managedConn.close(); if (retryHandler.retryRequest(ex, wrapper.getExecCount(), context)) { if (this.log.isInfoEnabled()) { this.log.info("I/O exception (" + ex.getClass().getName() + ") caught when processing request: " + ex.getMessage()); } if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage(), ex); } this.log.info("Retrying request"); retryReason = ex; } else { throw ex; } // If we have a direct route to the target host // just re-open connection and re-try the request if (!route.isTunnelled()) { this.log.debug("Reopening the direct connection."); managedConn.open(route, context, params); } else { // otherwise give up this.log.debug("Proxied connection. Need to start over."); retrying = false; } } } if (response == null) { // Need to start over continue; } // Run response protocol interceptors response.setParams(params); requestExec.postProcess(response, httpProcessor, context); // The connection is in or can be brought to a re-usable state. reuse = reuseStrategy.keepAlive(response, context); if (reuse) { // Set the idle duration of this connection long duration = keepAliveStrategy.getKeepAliveDuration(response, context); managedConn.setIdleDuration(duration, TimeUnit.MILLISECONDS); if (this.log.isDebugEnabled()) { if (duration >= 0) { this.log.debug("Connection can be kept alive for " + duration + " ms"); } else { this.log.debug("Connection can be kept alive indefinitely"); } } } RoutedRequest followup = handleResponse(roureq, response, context); if (followup == null) { done = true; } else { if (reuse) { // Make sure the response body is fully consumed, if present HttpEntity entity = response.getEntity(); if (entity != null) { entity.consumeContent(); } // entity consumed above is not an auto-release entity, // need to mark the connection re-usable explicitly managedConn.markReusable(); } else { managedConn.close(); } // check if we can use the same connection for the followup if (!followup.getRoute().equals(roureq.getRoute())) { releaseConnection(); } roureq = followup; } if (managedConn != null && userToken == null) { userToken = userTokenHandler.getUserToken(context); context.setAttribute(ClientContext.USER_TOKEN, userToken); if (userToken != null) { managedConn.setState(userToken); } } } // while not done // check for entity, release connection if possible if ((response == null) || (response.getEntity() == null) || !response.getEntity().isStreaming()) { // connection not needed and (assumed to be) in re-usable state if (reuse) managedConn.markReusable(); releaseConnection(); } else { // install an auto-release entity HttpEntity entity = response.getEntity(); entity = new BasicManagedEntity(entity, managedConn, reuse); response.setEntity(entity); } return response; } catch (HttpException ex) { abortConnection(); throw ex; } catch (IOException ex) { abortConnection(); throw ex; } catch (RuntimeException ex) { abortConnection(); throw ex; } }
From source file:org.robolectric.shadows.httpclient.DefaultRequestDirector.java
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) throws HttpException, IOException { HttpRequest orig = request;//from www . j a va 2 s . co m RequestWrapper origWrapper = wrapRequest(orig); origWrapper.setParams(params); HttpRoute origRoute = determineRoute(target, origWrapper, context); virtualHost = (HttpHost) orig.getParams().getParameter(ClientPNames.VIRTUAL_HOST); RoutedRequest roureq = new RoutedRequest(origWrapper, origRoute); long timeout = ConnManagerParams.getTimeout(params); int execCount = 0; boolean reuse = false; boolean done = false; try { HttpResponse response = null; while (!done) { // In this loop, the RoutedRequest may be replaced by a // followup request and route. The request and route passed // in the method arguments will be replaced. The original // request is still available in 'orig'. RequestWrapper wrapper = roureq.getRequest(); HttpRoute route = roureq.getRoute(); response = null; // See if we have a user token bound to the execution context Object userToken = context.getAttribute(ClientContext.USER_TOKEN); // Allocate connection if needed if (managedConn == null) { ClientConnectionRequest connRequest = connManager.requestConnection(route, userToken); if (orig instanceof AbortableHttpRequest) { ((AbortableHttpRequest) orig).setConnectionRequest(connRequest); } try { managedConn = connRequest.getConnection(timeout, TimeUnit.MILLISECONDS); } catch (InterruptedException interrupted) { InterruptedIOException iox = new InterruptedIOException(); iox.initCause(interrupted); throw iox; } if (HttpConnectionParams.isStaleCheckingEnabled(params)) { // validate connection if (managedConn.isOpen()) { this.log.debug("Stale connection check"); if (managedConn.isStale()) { this.log.debug("Stale connection detected"); managedConn.close(); } } } } if (orig instanceof AbortableHttpRequest) { ((AbortableHttpRequest) orig).setReleaseTrigger(managedConn); } // Reopen connection if needed if (!managedConn.isOpen()) { managedConn.open(route, context, params); } else { managedConn.setSocketTimeout(HttpConnectionParams.getSoTimeout(params)); } try { establishRoute(route, context); } catch (TunnelRefusedException ex) { if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage()); } response = ex.getResponse(); break; } // Reset headers on the request wrapper wrapper.resetHeaders(); // Re-write request URI if needed rewriteRequestURI(wrapper, route); // Use virtual host if set target = virtualHost; if (target == null) { target = route.getTargetHost(); } HttpHost proxy = route.getProxyHost(); // Populate the execution context context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target); context.setAttribute(ExecutionContext.HTTP_PROXY_HOST, proxy); context.setAttribute(ExecutionContext.HTTP_CONNECTION, managedConn); context.setAttribute(ClientContext.TARGET_AUTH_STATE, targetAuthState); context.setAttribute(ClientContext.PROXY_AUTH_STATE, proxyAuthState); // Run request protocol interceptors requestExec.preProcess(wrapper, httpProcessor, context); boolean retrying = true; Exception retryReason = null; while (retrying) { // Increment total exec count (with redirects) execCount++; // Increment exec count for this particular request wrapper.incrementExecCount(); if (!wrapper.isRepeatable()) { this.log.debug("Cannot retry non-repeatable request"); if (retryReason != null) { throw new NonRepeatableRequestException("Cannot retry request " + "with a non-repeatable request entity. The cause lists the " + "reason the original request failed: " + retryReason); } else { throw new NonRepeatableRequestException( "Cannot retry request " + "with a non-repeatable request entity."); } } try { if (this.log.isDebugEnabled()) { this.log.debug("Attempt " + execCount + " to execute request"); } response = requestExec.execute(wrapper, managedConn, context); retrying = false; } catch (IOException ex) { this.log.debug("Closing the connection."); managedConn.close(); if (retryHandler.retryRequest(ex, wrapper.getExecCount(), context)) { if (this.log.isInfoEnabled()) { this.log.info("I/O exception (" + ex.getClass().getName() + ") caught when processing request: " + ex.getMessage()); } if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage(), ex); } this.log.info("Retrying request"); retryReason = ex; } else { throw ex; } // If we have a direct route to the target host // just re-open connection and re-try the request if (!route.isTunnelled()) { this.log.debug("Reopening the direct connection."); managedConn.open(route, context, params); } else { // otherwise give up this.log.debug("Proxied connection. Need to start over."); retrying = false; } } } if (response == null) { // Need to start over continue; } // Run response protocol interceptors response.setParams(params); requestExec.postProcess(response, httpProcessor, context); // The connection is in or can be brought to a re-usable state. reuse = reuseStrategy.keepAlive(response, context); if (reuse) { // Set the idle duration of this connection long duration = keepAliveStrategy.getKeepAliveDuration(response, context); managedConn.setIdleDuration(duration, TimeUnit.MILLISECONDS); if (this.log.isDebugEnabled()) { if (duration >= 0) { this.log.debug("Connection can be kept alive for " + duration + " ms"); } else { this.log.debug("Connection can be kept alive indefinitely"); } } } RoutedRequest followup = handleResponse(roureq, response, context); if (followup == null) { done = true; } else { if (reuse) { // Make sure the response body is fully consumed, if present HttpEntity entity = response.getEntity(); if (entity != null) { entity.consumeContent(); } // entity consumed above is not an auto-release entity, // need to mark the connection re-usable explicitly managedConn.markReusable(); } else { managedConn.close(); } // check if we can use the same connection for the followup if (!followup.getRoute().equals(roureq.getRoute())) { releaseConnection(); } roureq = followup; } if (managedConn != null && userToken == null) { userToken = userTokenHandler.getUserToken(context); context.setAttribute(ClientContext.USER_TOKEN, userToken); if (userToken != null) { managedConn.setState(userToken); } } } // while not done // check for entity, release connection if possible if ((response == null) || (response.getEntity() == null) || !response.getEntity().isStreaming()) { // connection not needed and (assumed to be) in re-usable state if (reuse) managedConn.markReusable(); releaseConnection(); } else { // install an auto-release entity HttpEntity entity = response.getEntity(); entity = new BasicManagedEntity(entity, managedConn, reuse); response.setEntity(entity); } return response; } catch (HttpException | RuntimeException | IOException ex) { abortConnection(); throw ex; } }
From source file:org.vietspider.net.apache.DefaultRequestDirector.java
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) throws HttpException, IOException { HttpRequest orig = request;//from w ww. j av a2 s .c om RequestWrapper origWrapper = wrapRequest(orig); origWrapper.setParams(params); HttpRoute origRoute = determineRoute(target, origWrapper, context); virtualHost = (HttpHost) orig.getParams().getParameter(ClientPNames.VIRTUAL_HOST); RoutedRequest roureq = new RoutedRequest(origWrapper, origRoute); long timeout = HttpConnectionParams.getConnectionTimeout(params); boolean reuse = false; boolean done = false; try { HttpResponse response = null; while (!done) { // In this loop, the RoutedRequest may be replaced by a // followup request and route. The request and route passed // in the method arguments will be replaced. The original // request is still available in 'orig'. RequestWrapper wrapper = roureq.getRequest(); HttpRoute route = roureq.getRoute(); response = null; // See if we have a user token bound to the execution context Object userToken = context.getAttribute(ClientContext.USER_TOKEN); // Allocate connection if needed if (managedConn == null) { ClientConnectionRequest connRequest = connManager.requestConnection(route, userToken); if (orig instanceof AbortableHttpRequest) { ((AbortableHttpRequest) orig).setConnectionRequest(connRequest); } try { // if(timeout < 1) timeout = 30000; // System.out.println(" =========== chay vao day roi nhe " + timeout ); // System.out.println(connRequest); managedConn = connRequest.getConnection(timeout, TimeUnit.MILLISECONDS); // System.out.println("get thuc chuyen nay"); } catch (InterruptedException interrupted) { InterruptedIOException iox = new InterruptedIOException(); iox.initCause(interrupted); throw iox; } if (HttpConnectionParams.isStaleCheckingEnabled(params)) { // validate connection if (managedConn.isOpen()) { this.log.debug("Stale connection check"); if (managedConn.isStale()) { this.log.debug("Stale connection detected"); managedConn.close(); } } } } if (orig instanceof AbortableHttpRequest) { ((AbortableHttpRequest) orig).setReleaseTrigger(managedConn); } try { tryConnect(roureq, context); } catch (TunnelRefusedException ex) { if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage()); } response = ex.getResponse(); break; } // Reset headers on the request wrapper wrapper.resetHeaders(); // Re-write request URI if needed rewriteRequestURI(wrapper, route); // Use virtual host if set target = virtualHost; if (target == null) { target = route.getTargetHost(); } HttpHost proxy = route.getProxyHost(); // Populate the execution context context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, target); context.setAttribute(ExecutionContext.HTTP_PROXY_HOST, proxy); context.setAttribute(ExecutionContext.HTTP_CONNECTION, managedConn); context.setAttribute(ClientContext.TARGET_AUTH_STATE, targetAuthState); context.setAttribute(ClientContext.PROXY_AUTH_STATE, proxyAuthState); // Run request protocol interceptors requestExec.preProcess(wrapper, httpProcessor, context); response = tryExecute(roureq, context); if (response == null) { // Need to start over continue; } // Run response protocol interceptors response.setParams(params); requestExec.postProcess(response, httpProcessor, context); // The connection is in or can be brought to a re-usable state. reuse = reuseStrategy.keepAlive(response, context); if (reuse) { // 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); } managedConn.setIdleDuration(duration, TimeUnit.MILLISECONDS); } RoutedRequest followup = handleResponse(roureq, response, context); if (followup == null) { done = true; } else { if (reuse) { // Make sure the response body is fully consumed, if present HttpEntity entity = response.getEntity(); EntityUtils.consume(entity); // entity consumed above is not an auto-release entity, // need to mark the connection re-usable explicitly managedConn.markReusable(); } else { managedConn.close(); } // check if we can use the same connection for the followup if (!followup.getRoute().equals(roureq.getRoute())) { releaseConnection(); } roureq = followup; } if (managedConn != null && userToken == null) { userToken = userTokenHandler.getUserToken(context); context.setAttribute(ClientContext.USER_TOKEN, userToken); if (userToken != null) { managedConn.setState(userToken); } } } // while not done // check for entity, release connection if possible if ((response == null) || (response.getEntity() == null) || !response.getEntity().isStreaming()) { // connection not needed and (assumed to be) in re-usable state if (reuse) managedConn.markReusable(); releaseConnection(); } else { // install an auto-release entity HttpEntity entity = response.getEntity(); entity = new BasicManagedEntity(entity, managedConn, reuse); response.setEntity(entity); } return response; } catch (ConnectionShutdownException ex) { InterruptedIOException ioex = new InterruptedIOException("Connection has been shut down"); ioex.initCause(ex); throw ioex; } catch (HttpException ex) { abortConnection(); throw ex; } catch (IOException ex) { abortConnection(); throw ex; } catch (RuntimeException ex) { abortConnection(); throw ex; } }
From source file:com.groupon.odo.bmp.http.BrowserMobHttpClient.java
public BrowserMobHttpClient(StreamManager streamManager, AtomicInteger requestCounter) { this.requestCounter = requestCounter; SchemeRegistry schemeRegistry = new SchemeRegistry(); hostNameResolver = new BrowserMobHostNameResolver(new Cache(DClass.ANY)); this.socketFactory = new SimulatedSocketFactory(hostNameResolver, streamManager); this.sslSocketFactory = new TrustingSSLSocketFactory(hostNameResolver, streamManager); this.sslSocketFactory.setHostnameVerifier(new AllowAllHostnameVerifier()); schemeRegistry.register(new Scheme("http", 80, socketFactory)); schemeRegistry.register(new Scheme("https", 443, sslSocketFactory)); httpClientConnMgr = new ThreadSafeClientConnManager(schemeRegistry) { @Override//w w w.j a va2 s . c om public ClientConnectionRequest requestConnection(HttpRoute route, Object state) { final ClientConnectionRequest wrapped = super.requestConnection(route, state); return new ClientConnectionRequest() { @Override public ManagedClientConnection getConnection(long timeout, TimeUnit tunit) throws InterruptedException, ConnectionPoolTimeoutException { Date start = new Date(); try { return wrapped.getConnection(timeout, tunit); } finally { RequestInfo.get().blocked(start, new Date()); } } @Override public void abortRequest() { wrapped.abortRequest(); } }; } }; // MOB-338: 30 total connections and 6 connections per host matches the behavior in Firefox 3 httpClientConnMgr.setMaxTotal(30); httpClientConnMgr.setDefaultMaxPerRoute(6); httpClient = new DefaultHttpClient(httpClientConnMgr) { @Override protected HttpRequestExecutor createRequestExecutor() { return new HttpRequestExecutor() { @Override protected HttpResponse doSendRequest(HttpRequest request, HttpClientConnection conn, HttpContext context) throws IOException, HttpException { long requestHeadersSize = request.getRequestLine().toString().length() + 4; long requestBodySize = 0; for (Header header : request.getAllHeaders()) { requestHeadersSize += header.toString().length() + 2; if (header.getName().equals("Content-Length")) { requestBodySize += Integer.valueOf(header.getValue()); } } HarEntry entry = RequestInfo.get().getEntry(); if (entry != null) { entry.getRequest().setHeadersSize(requestHeadersSize); entry.getRequest().setBodySize(requestBodySize); } Date start = new Date(); HttpResponse response = super.doSendRequest(request, conn, context); RequestInfo.get().send(start, new Date()); return response; } @Override protected HttpResponse doReceiveResponse(HttpRequest request, HttpClientConnection conn, HttpContext context) throws HttpException, IOException { Date start = new Date(); HttpResponse response = super.doReceiveResponse(request, conn, context); long responseHeadersSize = response.getStatusLine().toString().length() + 4; for (Header header : response.getAllHeaders()) { responseHeadersSize += header.toString().length() + 2; } HarEntry entry = RequestInfo.get().getEntry(); if (entry != null) { entry.getResponse().setHeadersSize(responseHeadersSize); } RequestInfo.get().wait(start, new Date()); return response; } }; } }; credsProvider = new WildcardMatchingCredentialsProvider(); httpClient.setCredentialsProvider(credsProvider); httpClient.addRequestInterceptor(new PreemptiveAuth(), 0); httpClient.getParams().setParameter(ClientPNames.HANDLE_REDIRECTS, true); httpClient.getParams().setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY); httpClient.getParams().setParameter(CookieSpecPNames.SINGLE_COOKIE_HEADER, Boolean.TRUE); setRetryCount(0); // we always set this to false so it can be handled manually: httpClient.getParams().setParameter(ClientPNames.HANDLE_REDIRECTS, false); HttpClientInterrupter.watch(this); setConnectionTimeout(60000); setSocketOperationTimeout(60000); setRequestTimeout(-1); }
From source file:org.glassfish.jersey.apache.connector.HelloWorldTest.java
/** * JERSEY-2157 reproducer./*from w ww . j a v a 2 s . c om*/ * <p> * The test ensures that entities of the error responses which cause * WebApplicationException being thrown by a JAX-RS client are buffered * and that the underlying input connections are automatically released * in such case. */ @Test public void testConnectionClosingOnExceptionsForErrorResponses() { final BasicClientConnectionManager cm = new BasicClientConnectionManager(); final AtomicInteger connectionCounter = new AtomicInteger(0); final ClientConfig config = new ClientConfig().property(ApacheClientProperties.CONNECTION_MANAGER, new ClientConnectionManager() { @Override public SchemeRegistry getSchemeRegistry() { return cm.getSchemeRegistry(); } @Override public ClientConnectionRequest requestConnection(final HttpRoute route, final Object state) { connectionCounter.incrementAndGet(); final ClientConnectionRequest wrappedRequest = cm.requestConnection(route, state); /** * To explain the following long piece of code: * * All the code does is to just create a wrapper implementations * for the AHC connection management interfaces. * * The only really important piece of code is the * {@link org.apache.http.conn.ManagedClientConnection#releaseConnection()} implementation, * where the connectionCounter is decremented when a managed connection instance * is released by AHC runtime. In our test, this is expected to happen * as soon as the exception is created for an error response * (as the error response entity gets buffered in * {@link org.glassfish.jersey.client.JerseyInvocation#convertToException(javax.ws.rs.core.Response)}). */ return new ClientConnectionRequest() { @Override public ManagedClientConnection getConnection(long timeout, TimeUnit tunit) throws InterruptedException, ConnectionPoolTimeoutException { final ManagedClientConnection wrappedConnection = wrappedRequest .getConnection(timeout, tunit); return new ManagedClientConnection() { @Override public boolean isSecure() { return wrappedConnection.isSecure(); } @Override public HttpRoute getRoute() { return wrappedConnection.getRoute(); } @Override public SSLSession getSSLSession() { return wrappedConnection.getSSLSession(); } @Override public void open(HttpRoute route, HttpContext context, HttpParams params) throws IOException { wrappedConnection.open(route, context, params); } @Override public void tunnelTarget(boolean secure, HttpParams params) throws IOException { wrappedConnection.tunnelTarget(secure, params); } @Override public void tunnelProxy(HttpHost next, boolean secure, HttpParams params) throws IOException { wrappedConnection.tunnelProxy(next, secure, params); } @Override public void layerProtocol(HttpContext context, HttpParams params) throws IOException { wrappedConnection.layerProtocol(context, params); } @Override public void markReusable() { wrappedConnection.markReusable(); } @Override public void unmarkReusable() { wrappedConnection.unmarkReusable(); } @Override public boolean isMarkedReusable() { return wrappedConnection.isMarkedReusable(); } @Override public void setState(Object state) { wrappedConnection.setState(state); } @Override public Object getState() { return wrappedConnection.getState(); } @Override public void setIdleDuration(long duration, TimeUnit unit) { wrappedConnection.setIdleDuration(duration, unit); } @Override public boolean isResponseAvailable(int timeout) throws IOException { return wrappedConnection.isResponseAvailable(timeout); } @Override public void sendRequestHeader(HttpRequest request) throws HttpException, IOException { wrappedConnection.sendRequestHeader(request); } @Override public void sendRequestEntity(HttpEntityEnclosingRequest request) throws HttpException, IOException { wrappedConnection.sendRequestEntity(request); } @Override public HttpResponse receiveResponseHeader() throws HttpException, IOException { return wrappedConnection.receiveResponseHeader(); } @Override public void receiveResponseEntity(HttpResponse response) throws HttpException, IOException { wrappedConnection.receiveResponseEntity(response); } @Override public void flush() throws IOException { wrappedConnection.flush(); } @Override public void close() throws IOException { wrappedConnection.close(); } @Override public boolean isOpen() { return wrappedConnection.isOpen(); } @Override public boolean isStale() { return wrappedConnection.isStale(); } @Override public void setSocketTimeout(int timeout) { wrappedConnection.setSocketTimeout(timeout); } @Override public int getSocketTimeout() { return wrappedConnection.getSocketTimeout(); } @Override public void shutdown() throws IOException { wrappedConnection.shutdown(); } @Override public HttpConnectionMetrics getMetrics() { return wrappedConnection.getMetrics(); } @Override public InetAddress getLocalAddress() { return wrappedConnection.getLocalAddress(); } @Override public int getLocalPort() { return wrappedConnection.getLocalPort(); } @Override public InetAddress getRemoteAddress() { return wrappedConnection.getRemoteAddress(); } @Override public int getRemotePort() { return wrappedConnection.getRemotePort(); } @Override public void releaseConnection() throws IOException { connectionCounter.decrementAndGet(); wrappedConnection.releaseConnection(); } @Override public void abortConnection() throws IOException { wrappedConnection.abortConnection(); } @Override public String getId() { return wrappedConnection.getId(); } @Override public void bind(Socket socket) throws IOException { wrappedConnection.bind(socket); } @Override public Socket getSocket() { return wrappedConnection.getSocket(); } }; } @Override public void abortRequest() { wrappedRequest.abortRequest(); } }; } @Override public void releaseConnection(ManagedClientConnection conn, long keepalive, TimeUnit tunit) { cm.releaseConnection(conn, keepalive, tunit); } @Override public void closeExpiredConnections() { cm.closeExpiredConnections(); } @Override public void closeIdleConnections(long idletime, TimeUnit tunit) { cm.closeIdleConnections(idletime, tunit); } @Override public void shutdown() { cm.shutdown(); } }); config.connectorProvider(new ApacheConnectorProvider()); final Client client = ClientBuilder.newClient(config); final WebTarget rootTarget = client.target(getBaseUri()).path(ROOT_PATH); // Test that connection is getting closed properly for error responses. try { final String response = rootTarget.path("error").request().get(String.class); fail("Exception expected. Received: " + response); } catch (InternalServerErrorException isee) { // do nothing - connection should be closed properly by now } // Fail if the previous connection has not been closed automatically. assertEquals(0, connectionCounter.get()); try { final String response = rootTarget.path("error2").request().get(String.class); fail("Exception expected. Received: " + response); } catch (InternalServerErrorException isee) { assertEquals("Received unexpected data.", "Error2.", isee.getResponse().readEntity(String.class)); // Test buffering: // second read would fail if entity was not buffered assertEquals("Unexpected data in the entity buffer.", "Error2.", isee.getResponse().readEntity(String.class)); } assertEquals(0, connectionCounter.get()); }