List of usage examples for org.apache.http.conn ManagedClientConnection abortConnection
void abortConnection() throws IOException;
From source file:gr.wavesoft.webng.io.web.WebStreams.java
public static HttpResponse httpGET(URL url, HashMap<String, String> headers) throws IOException { try {/* w w w . j a va 2 s.c o m*/ // 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:com.grendelscan.commons.http.apache_overrides.client.CustomClientRequestDirector.java
/** * Shuts down the connection.//from ww w . j a v a 2 s . c o m * This method is called from a <code>catch</code> block in {@link #execute * execute} during exception handling. */ private void abortConnection() { ManagedClientConnection mcc = managedConn; if (mcc != null) { // we got here as the result of an exception // no response will be returned, release the connection managedConn = null; try { mcc.abortConnection(); } catch (IOException ex) { LOGGER.trace(ex.getMessage(), ex); } // ensure the connection manager properly releases this connection try { mcc.releaseConnection(); } catch (IOException ignored) { LOGGER.debug("Error releasing connection", ignored); } } }
From source file:org.robolectric.shadows.httpclient.DefaultRequestDirector.java
/** * Shuts down the connection.//from www .ja va 2 s. c o m * This method is called from a <code>catch</code> block in * {@link #execute execute} during exception handling. */ private void abortConnection() { ManagedClientConnection mcc = managedConn; if (mcc != null) { // we got here as the result of an exception // no response will be returned, release the connection managedConn = null; try { mcc.abortConnection(); } catch (IOException ex) { if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage(), ex); } } // ensure the connection manager properly releases this connection try { mcc.releaseConnection(); } catch (IOException ignored) { this.log.debug("Error releasing connection", ignored); } } }
From source file:org.ellis.yun.search.test.httpclient.HttpClientTest.java
/** * HTTPHttpClient<br>/*from ww w. j a v a2 s. c o m*/ * 'http.connection'HttpConnection? ? * 'http.target_host'HttpHost ? * 'http.proxy_host'HttpHost? ? * 'http.request'HttpRequestHTTP ? * 'http.response'HttpResponseHTTP? ? * 'http.request_sent'java.lang.Boolean?? * * @throws Exception */ @Test @SuppressWarnings("deprecation") public void testHttpContext() throws Exception { DefaultHttpClient httpclient = new DefaultHttpClient(); // httpContext ?httpClienthttp? HttpContext httpContext = new BasicHttpContext(); HttpGet httpGet = new HttpGet(URL1); HttpResponse response = httpclient.execute(httpGet, httpContext); ManagedClientConnection connection = (ManagedClientConnection) httpContext .getAttribute(ExecutionContext.HTTP_CONNECTION); System.out.println("LocalAddr ==> " + connection.getLocalAddress().getHostAddress()); System.out.println("LocalPort ==> " + connection.getLocalPort()); System.out.println("RemoteAddr ==> " + connection.getRemoteAddress().getHostAddress()); System.out.println("RemotePort ==> " + connection.getRemotePort()); System.out.println("isOpen ==> " + connection.isOpen()); System.out.println("isSecure ==> " + connection.isSecure()); System.out.println("isStale ==> " + connection.isStale()); HttpHost targetHost = (HttpHost) httpContext.getAttribute(ExecutionContext.HTTP_TARGET_HOST); System.out.println(targetHost.toURI()); // HttpHost proxyHost = (HttpHost) httpContext // .getAttribute(ExecutionContext.HTTP_PROXY_HOST); // ?? HttpEntity entity = response.getEntity(); if (entity != null) { String content = parseEntity(entity); System.out.println(content); // ? entity.consumeContent(); } connection.abortConnection(); connection.shutdown(); }
From source file:org.glassfish.jersey.apache.connector.HelloWorldTest.java
/** * JERSEY-2157 reproducer./*w ww. ja v a 2s . co m*/ * <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()); }
From source file:org.apache.http.impl.client.DefaultRequestDirector.java
/** * Shuts down the connection.//w w w. jav a 2 s. co m * This method is called from a <code>catch</code> block in * {@link #execute execute} during exception handling. */ private void abortConnection() { final ManagedClientConnection mcc = managedConn; if (mcc != null) { // we got here as the result of an exception // no response will be returned, release the connection managedConn = null; try { mcc.abortConnection(); } catch (final IOException ex) { if (this.log.isDebugEnabled()) { this.log.debug(ex.getMessage(), ex); } } // ensure the connection manager properly releases this connection try { mcc.releaseConnection(); } catch (final IOException ignored) { this.log.debug("Error releasing connection", ignored); } } }