Example usage for org.apache.http.impl.conn CPoolEntry markRouteComplete

Introduction

In this page you can find the example usage for org.apache.http.impl.conn CPoolEntry markRouteComplete.

Prototype

public void markRouteComplete() 

Source Link

Usage

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

public void routeComplete(final HttpClientConnection managedConn, final HttpRoute route,
        final HttpContext context) throws IOException {
    Args.notNull(managedConn, "Managed Connection");
    Args.notNull(route, "HTTP route");
    synchronized (managedConn) {
        final CPoolEntry entry = CPoolProxy.getPoolEntry(managedConn);
        entry.markRouteComplete();
    }//from   ww  w .  java 2 s . c om
}

---

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();

    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  w w  w  . j  a  v  a2 s.  c o m*/
    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(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();

    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
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();

    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);/*from   w  ww  .  j av a 2 s . c o m*/
    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();

    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);//w  ww .j a  va  2  s.co  m
    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();
    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);/*from  ww w. ja v  a  2  s  .c o  m*/

    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();
    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);/*from  ww  w  . j ava  2s .c o  m*/

    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);
}

---