List of usage examples for org.apache.http.conn ManagedClientConnection receiveResponseHeader
HttpResponse receiveResponseHeader() throws HttpException, IOException;
From source file:httpclient.conn.ManagerConnectDirect.java
/** * Main entry point to this example.//from ww w .j av a 2 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 . ja v a2 s . c o 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 w w w . j av a2s . 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:org.glassfish.jersey.apache.connector.HelloWorldTest.java
/** * JERSEY-2157 reproducer.//from w w w . j a v a2s .c o 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()); }