Example usage for org.apache.http.conn ConnectionRequest get

Introduction

In this page you can find the example usage for org.apache.http.conn ConnectionRequest get.

Prototype

HttpClientConnection get(long timeout, TimeUnit tunit)
        throws InterruptedException, ExecutionException, ConnectionPoolTimeoutException;

Source Link

Document

Obtains a connection within a given time.

Usage

From source file:org.apache.solr.client.solrj.ConnectionReuseTest.java

public HttpClientConnection getConn(ConnectionRequest mConn)
        throws InterruptedException, ConnectionPoolTimeoutException, ExecutionException {
    HttpClientConnection conn = mConn.get(30, TimeUnit.SECONDS);

    return conn;/*ww  w . ja v a  2s  . c o  m*/
}

---

From source file:net.community.chest.gitcloud.facade.frontend.git.HttpClientConnectionManagerFactoryBean.java

@Inject
public HttpClientConnectionManagerFactoryBean(@Value(TTL_CONFIG_VALUE) long ttlSeconds,
        @Value(MAX_PER_ROUTE_CONFIG_VALUE) int defaultMaxPerRoute,
        @Value(MAX_TOTAL_CONFIG_VALUE) int maxTotal) {
    Validate.isTrue(ttlSeconds > 0L, "Invalid TTL value: %d", ttlSeconds);
    Validate.isTrue(defaultMaxPerRoute > 0, "Invalid max. per-route value: %d", defaultMaxPerRoute);
    Validate.isTrue(maxTotal > 0, "Invalid max. total value: %d", maxTotal);

    // TODO use a different connections registry with an all-trusting HTTPS socket factory
    // TODO log the total stats and/or pre-route one at DEBUG/INFO level every few minutes/seconds or every N requests
    manager = new PoolingHttpClientConnectionManager(ttlSeconds, TimeUnit.SECONDS) {
        @Override//from  w w w.j  av a2 s.c o  m
        @SuppressWarnings("synthetic-access")
        public ConnectionRequest requestConnection(final HttpRoute route, Object state) {
            final ConnectionRequest req = super.requestConnection(route, state);
            if (logger.isTraceEnabled()) {
                return new ConnectionRequest() {
                    @Override
                    public boolean cancel() {
                        logger.trace("requestConnection(" + route + ") cancelling");
                        return req.cancel();
                    }

                    @Override
                    public HttpClientConnection get(long timeout, TimeUnit tunit)
                            throws InterruptedException, ExecutionException, ConnectionPoolTimeoutException {
                        HttpClientConnection conn = req.get(timeout, tunit);
                        logger.trace(
                                "requestConnection(" + route + ")[" + timeout + " " + tunit + "]: " + conn);
                        return conn;
                    }
                };
            }

            return req;
        }

        @Override
        @SuppressWarnings("synthetic-access")
        public void releaseConnection(HttpClientConnection managedConn, Object state, long keepalive,
                TimeUnit tunit) {
            if (logger.isTraceEnabled()) {
                logger.trace("releaseConnection(" + keepalive + " " + tunit + "]: " + managedConn);
            }
            super.releaseConnection(managedConn, state, keepalive, tunit);
        }

        @Override
        @SuppressWarnings("synthetic-access")
        public void connect(HttpClientConnection managedConn, HttpRoute route, int connectTimeout,
                HttpContext context) throws IOException {
            if (logger.isTraceEnabled()) {
                logger.trace("connect(" + route + ")[timeout=" + connectTimeout + "]: " + managedConn);
            }
            super.connect(managedConn, route, connectTimeout, context);
        }
    };
    manager.setDefaultMaxPerRoute(defaultMaxPerRoute);
    manager.setMaxTotal(maxTotal);
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test
public void testLeaseRelease() throws Exception {
    final HttpHost target = new HttpHost("localhost");
    final HttpRoute route = new HttpRoute(target);

    final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1,
            TimeUnit.MILLISECONDS);
    entry.markRouteComplete();//from  w w  w.  j av a  2 s.  c o m

    Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE);
    Mockito.when(socketFactoryRegistry.lookup("http")).thenReturn(plainSocketFactory);
    Mockito.when(schemePortResolver.resolve(target)).thenReturn(80);
    Mockito.when(plainSocketFactory.createSocket(Mockito.<HttpContext>any())).thenReturn(socket);

    Mockito.when(conn.isOpen()).thenReturn(true);
    Mockito.when(future.isCancelled()).thenReturn(false);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS);
    Assert.assertNotNull(conn1);
    Assert.assertNotSame(conn, conn1);

    mgr.releaseConnection(conn1, null, 0, TimeUnit.MILLISECONDS);

    Mockito.verify(pool).release(entry, true);
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test
public void testReleaseRouteIncomplete() throws Exception {
    final HttpHost target = new HttpHost("localhost");
    final HttpRoute route = new HttpRoute(target);

    final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1,
            TimeUnit.MILLISECONDS);

    Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE);
    Mockito.when(socketFactoryRegistry.lookup("http")).thenReturn(plainSocketFactory);
    Mockito.when(schemePortResolver.resolve(target)).thenReturn(80);
    Mockito.when(plainSocketFactory.createSocket(Mockito.<HttpContext>any())).thenReturn(socket);

    Mockito.when(conn.isOpen()).thenReturn(true);
    Mockito.when(future.isCancelled()).thenReturn(false);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS);
    Assert.assertNotNull(conn1);/*from www. ja  v a  2 s .  c  om*/
    Assert.assertNotSame(conn, conn1);

    mgr.releaseConnection(conn1, null, 0, TimeUnit.MILLISECONDS);

    Mockito.verify(pool).release(entry, false);
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test(expected = InterruptedException.class)
public void testLeaseFutureCancelled() throws Exception {
    final HttpHost target = new HttpHost("localhost");
    final HttpRoute route = new HttpRoute(target);

    final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1,
            TimeUnit.MILLISECONDS);
    entry.markRouteComplete();/*  w w  w .  j  a v a2  s .  co  m*/

    Mockito.when(future.isCancelled()).thenReturn(Boolean.TRUE);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    connRequest1.get(1, TimeUnit.SECONDS);
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test(expected = ConnectionPoolTimeoutException.class)
public void testLeaseFutureTimeout() throws Exception {
    final HttpHost target = new HttpHost("localhost");
    final HttpRoute route = new HttpRoute(target);

    Mockito.when(future.isCancelled()).thenReturn(Boolean.TRUE);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenThrow(new TimeoutException());
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    connRequest1.get(1, TimeUnit.SECONDS);
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test
public void testReleaseReusable() throws Exception {
    final HttpHost target = new HttpHost("localhost");
    final HttpRoute route = new HttpRoute(target);

    final CPoolEntry entry = Mockito
            .spy(new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1, TimeUnit.MILLISECONDS));
    entry.markRouteComplete();//from  ww  w.j a  v  a  2  s  .  c o m

    Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);
    Mockito.when(conn.isOpen()).thenReturn(Boolean.TRUE);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS);
    Assert.assertNotNull(conn1);
    Assert.assertTrue(conn1.isOpen());

    mgr.releaseConnection(conn1, "some state", 0, TimeUnit.MILLISECONDS);

    Mockito.verify(pool).release(entry, true);
    Mockito.verify(entry).setState("some state");
    Mockito.verify(entry).updateExpiry(Mockito.anyLong(), Mockito.eq(TimeUnit.MILLISECONDS));
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test
public void testReleaseNonReusable() throws Exception {
    final HttpHost target = new HttpHost("localhost");
    final HttpRoute route = new HttpRoute(target);

    final CPoolEntry entry = Mockito
            .spy(new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1, TimeUnit.MILLISECONDS));
    entry.markRouteComplete();/*from  ww w .java 2s  . c o  m*/

    Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);
    Mockito.when(conn.isOpen()).thenReturn(Boolean.FALSE);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS);
    Assert.assertNotNull(conn1);
    Assert.assertFalse(conn1.isOpen());

    mgr.releaseConnection(conn1, "some state", 0, TimeUnit.MILLISECONDS);

    Mockito.verify(pool).release(entry, false);
    Mockito.verify(entry, Mockito.never()).setState(Mockito.anyObject());
    Mockito.verify(entry, Mockito.never()).updateExpiry(Mockito.anyLong(), Mockito.eq(TimeUnit.MILLISECONDS));
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test
public void testTargetConnect() throws Exception {
    final HttpHost target = new HttpHost("somehost", -1, "https");
    final InetAddress remote = InetAddress.getByAddress(new byte[] { 10, 0, 0, 1 });
    final InetAddress local = InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 });
    final HttpRoute route = new HttpRoute(target, local, true);

    final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1,
            TimeUnit.MILLISECONDS);
    entry.markRouteComplete();// w  w  w. j  a  v a  2  s .c  o m
    Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE);
    Mockito.when(conn.isOpen()).thenReturn(true);
    Mockito.when(future.isCancelled()).thenReturn(false);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS);
    Assert.assertNotNull(conn1);

    final HttpClientContext context = HttpClientContext.create();
    final SocketConfig sconfig = SocketConfig.custom().build();

    mgr.setDefaultSocketConfig(sconfig);

    Mockito.when(dnsResolver.resolve("somehost")).thenReturn(new InetAddress[] { remote });
    Mockito.when(schemePortResolver.resolve(target)).thenReturn(8443);
    Mockito.when(socketFactoryRegistry.lookup("https")).thenReturn(plainSocketFactory);
    Mockito.when(plainSocketFactory.createSocket(Mockito.<HttpContext>any())).thenReturn(socket);
    Mockito.when(plainSocketFactory.connectSocket(Mockito.anyInt(), Mockito.eq(socket), Mockito.<HttpHost>any(),
            Mockito.<InetSocketAddress>any(), Mockito.<InetSocketAddress>any(), Mockito.<HttpContext>any()))
            .thenReturn(socket);

    mgr.connect(conn1, route, 123, context);

    Mockito.verify(dnsResolver, Mockito.times(1)).resolve("somehost");
    Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(target);
    Mockito.verify(plainSocketFactory, Mockito.times(1)).createSocket(context);
    Mockito.verify(plainSocketFactory, Mockito.times(1)).connectSocket(123, socket, target,
            new InetSocketAddress(remote, 8443), new InetSocketAddress(local, 0), context);

    mgr.routeComplete(conn1, route, context);
}

---

From source file:org.apache.http.impl.conn.TestPoolingHttpClientConnectionManager.java

@Test
public void testProxyConnectAndUpgrade() throws Exception {
    final HttpHost target = new HttpHost("somehost", -1, "https");
    final HttpHost proxy = new HttpHost("someproxy", 8080);
    final InetAddress remote = InetAddress.getByAddress(new byte[] { 10, 0, 0, 1 });
    final InetAddress local = InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 });
    final HttpRoute route = new HttpRoute(target, local, proxy, true);

    final CPoolEntry entry = new CPoolEntry(LogFactory.getLog(getClass()), "id", route, conn, -1,
            TimeUnit.MILLISECONDS);
    entry.markRouteComplete();//from w  ww  . ja v a 2 s .  c  o m
    Mockito.when(future.isCancelled()).thenReturn(Boolean.FALSE);
    Mockito.when(conn.isOpen()).thenReturn(true);
    Mockito.when(future.isCancelled()).thenReturn(false);
    Mockito.when(future.get(1, TimeUnit.SECONDS)).thenReturn(entry);
    Mockito.when(pool.lease(route, null, null)).thenReturn(future);

    final ConnectionRequest connRequest1 = mgr.requestConnection(route, null);
    final HttpClientConnection conn1 = connRequest1.get(1, TimeUnit.SECONDS);
    Assert.assertNotNull(conn1);

    final ConnectionSocketFactory plainsf = Mockito.mock(ConnectionSocketFactory.class);
    final LayeredConnectionSocketFactory sslsf = Mockito.mock(LayeredConnectionSocketFactory.class);
    final Socket socket = Mockito.mock(Socket.class);
    final HttpClientContext context = HttpClientContext.create();
    final SocketConfig sconfig = SocketConfig.custom().build();
    final ConnectionConfig cconfig = ConnectionConfig.custom().build();

    mgr.setDefaultSocketConfig(sconfig);
    mgr.setDefaultConnectionConfig(cconfig);

    Mockito.when(dnsResolver.resolve("someproxy")).thenReturn(new InetAddress[] { remote });
    Mockito.when(schemePortResolver.resolve(proxy)).thenReturn(8080);
    Mockito.when(schemePortResolver.resolve(target)).thenReturn(8443);
    Mockito.when(socketFactoryRegistry.lookup("http")).thenReturn(plainsf);
    Mockito.when(socketFactoryRegistry.lookup("https")).thenReturn(sslsf);
    Mockito.when(plainsf.createSocket(Mockito.<HttpContext>any())).thenReturn(socket);
    Mockito.when(plainsf.connectSocket(Mockito.anyInt(), Mockito.eq(socket), Mockito.<HttpHost>any(),
            Mockito.<InetSocketAddress>any(), Mockito.<InetSocketAddress>any(), Mockito.<HttpContext>any()))
            .thenReturn(socket);

    mgr.connect(conn1, route, 123, context);

    Mockito.verify(dnsResolver, Mockito.times(1)).resolve("someproxy");
    Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(proxy);
    Mockito.verify(plainsf, Mockito.times(1)).createSocket(context);
    Mockito.verify(plainsf, Mockito.times(1)).connectSocket(123, socket, proxy,
            new InetSocketAddress(remote, 8080), new InetSocketAddress(local, 0), context);

    Mockito.when(conn.getSocket()).thenReturn(socket);

    mgr.upgrade(conn1, route, context);

    Mockito.verify(schemePortResolver, Mockito.times(1)).resolve(target);
    Mockito.verify(sslsf, Mockito.times(1)).createLayeredSocket(socket, "somehost", 8443, context);

    mgr.routeComplete(conn1, route, context);
}

---

• «
• 1
• 2
• »