| /* |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| * |
| */ |
| |
| package org.apache.hc.client5.testing.sync; |
| |
| import java.io.IOException; |
| import java.util.concurrent.TimeoutException; |
| |
| import org.apache.hc.client5.http.HttpRoute; |
| import org.apache.hc.client5.http.config.ConnectionConfig; |
| import org.apache.hc.client5.http.impl.classic.CloseableHttpClient; |
| import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager; |
| import org.apache.hc.client5.http.io.ConnectionEndpoint; |
| import org.apache.hc.client5.http.io.LeaseRequest; |
| import org.apache.hc.client5.http.protocol.HttpClientContext; |
| import org.apache.hc.client5.testing.classic.RandomHandler; |
| import org.apache.hc.client5.testing.sync.extension.TestClientResources; |
| import org.apache.hc.core5.http.ClassicHttpRequest; |
| import org.apache.hc.core5.http.ClassicHttpResponse; |
| import org.apache.hc.core5.http.HttpException; |
| import org.apache.hc.core5.http.HttpHost; |
| import org.apache.hc.core5.http.HttpStatus; |
| import org.apache.hc.core5.http.URIScheme; |
| import org.apache.hc.core5.http.impl.io.HttpRequestExecutor; |
| import org.apache.hc.core5.http.io.HttpClientConnection; |
| import org.apache.hc.core5.http.message.BasicClassicHttpRequest; |
| import org.apache.hc.core5.http.protocol.DefaultHttpProcessor; |
| import org.apache.hc.core5.http.protocol.HttpContext; |
| import org.apache.hc.core5.http.protocol.HttpProcessor; |
| import org.apache.hc.core5.http.protocol.RequestConnControl; |
| import org.apache.hc.core5.http.protocol.RequestContent; |
| import org.apache.hc.core5.http.protocol.RequestTargetHost; |
| import org.apache.hc.core5.pool.PoolConcurrencyPolicy; |
| import org.apache.hc.core5.pool.PoolReusePolicy; |
| import org.apache.hc.core5.testing.classic.ClassicTestServer; |
| import org.apache.hc.core5.util.TimeValue; |
| import org.apache.hc.core5.util.Timeout; |
| import org.junit.jupiter.api.Assertions; |
| import org.junit.jupiter.api.BeforeEach; |
| import org.junit.jupiter.api.Test; |
| import org.junit.jupiter.api.extension.RegisterExtension; |
| |
| /** |
| * Tests for {@code PoolingHttpClientConnectionManager} that do require a server |
| * to communicate with. |
| */ |
| public class TestConnectionManagement { |
| |
| public static final Timeout TIMEOUT = Timeout.ofMinutes(1); |
| |
| @RegisterExtension |
| private TestClientResources testResources = new TestClientResources(URIScheme.HTTP, TIMEOUT); |
| |
| ConnectionEndpoint.RequestExecutor exec; |
| |
| @BeforeEach |
| public void setup() { |
| exec = new ConnectionEndpoint.RequestExecutor() { |
| |
| final HttpRequestExecutor requestExecutor = new HttpRequestExecutor(); |
| final HttpProcessor httpProcessor = new DefaultHttpProcessor( |
| new RequestTargetHost(), new RequestContent(), new RequestConnControl()); |
| @Override |
| public ClassicHttpResponse execute(final ClassicHttpRequest request, |
| final HttpClientConnection conn, |
| final HttpContext context) throws IOException, HttpException { |
| requestExecutor.preProcess(request, httpProcessor, context); |
| final ClassicHttpResponse response = requestExecutor.execute(request, conn, context); |
| requestExecutor.postProcess(response, httpProcessor, context); |
| return response; |
| } |
| |
| }; |
| } |
| |
| public ClassicTestServer startServer() throws IOException { |
| return testResources.startServer(null, null, null); |
| } |
| |
| public CloseableHttpClient startClient() throws Exception { |
| return testResources.startClient(b -> {}, b -> {}); |
| } |
| |
| public HttpHost targetHost() { |
| return testResources.targetHost(); |
| } |
| |
| /** |
| * Tests releasing and re-using a connection after a response is read. |
| */ |
| @Test |
| public void testReleaseConnection() throws Exception { |
| final ClassicTestServer server = startServer(); |
| server.registerHandler("/random/*", new RandomHandler()); |
| final HttpHost target = targetHost(); |
| |
| startClient(); |
| |
| final PoolingHttpClientConnectionManager connManager = testResources.connManager(); |
| connManager.setMaxTotal(1); |
| |
| final HttpRoute route = new HttpRoute(target, null, false); |
| final int rsplen = 8; |
| final String uri = "/random/" + rsplen; |
| |
| final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", target, uri); |
| final HttpClientContext context = HttpClientContext.create(); |
| |
| final LeaseRequest leaseRequest1 = connManager.lease("id1", route, null); |
| final ConnectionEndpoint endpoint1 = leaseRequest1.get(Timeout.ZERO_MILLISECONDS); |
| |
| connManager.connect(endpoint1, null, context); |
| |
| try (final ClassicHttpResponse response1 = endpoint1.execute("id1", request, exec, context)) { |
| Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); |
| } |
| |
| // check that there is no auto-release by default |
| // this should fail quickly, connection has not been released |
| final LeaseRequest leaseRequest2 = connManager.lease("id2", route, null); |
| Assertions.assertThrows(TimeoutException.class, () -> leaseRequest2.get(Timeout.ofMilliseconds(10))); |
| |
| endpoint1.close(); |
| connManager.release(endpoint1, null, TimeValue.NEG_ONE_MILLISECOND); |
| final LeaseRequest leaseRequest3 = connManager.lease("id2", route, null); |
| final ConnectionEndpoint endpoint2 = leaseRequest3.get(Timeout.ZERO_MILLISECONDS); |
| Assertions.assertFalse(endpoint2.isConnected()); |
| |
| connManager.connect(endpoint2, null, context); |
| |
| try (final ClassicHttpResponse response2 = endpoint2.execute("id2", request, exec, context)) { |
| Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); |
| } |
| |
| // release connection after marking it for re-use |
| // expect the next connection obtained to be open |
| connManager.release(endpoint2, null, TimeValue.NEG_ONE_MILLISECOND); |
| |
| final LeaseRequest leaseRequest4 = connManager.lease("id3", route, null); |
| final ConnectionEndpoint endpoint3 = leaseRequest4.get(Timeout.ZERO_MILLISECONDS); |
| Assertions.assertTrue(endpoint3.isConnected()); |
| |
| // repeat the communication, no need to prepare the request again |
| try (final ClassicHttpResponse response3 = endpoint3.execute("id3", request, exec, context)) { |
| Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); |
| } |
| |
| connManager.release(endpoint3, null, TimeValue.NEG_ONE_MILLISECOND); |
| connManager.close(); |
| } |
| |
| /** |
| * Tests releasing with time limits. |
| */ |
| @Test |
| public void testReleaseConnectionWithTimeLimits() throws Exception { |
| final ClassicTestServer server = startServer(); |
| server.registerHandler("/random/*", new RandomHandler()); |
| final HttpHost target = targetHost(); |
| |
| startClient(); |
| |
| final PoolingHttpClientConnectionManager connManager = testResources.connManager(); |
| connManager.setMaxTotal(1); |
| |
| final HttpRoute route = new HttpRoute(target, null, false); |
| final int rsplen = 8; |
| final String uri = "/random/" + rsplen; |
| |
| final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", target, uri); |
| final HttpClientContext context = HttpClientContext.create(); |
| |
| final LeaseRequest leaseRequest1 = connManager.lease("id1", route, null); |
| final ConnectionEndpoint endpoint1 = leaseRequest1.get(Timeout.ZERO_MILLISECONDS); |
| connManager.connect(endpoint1, null, context); |
| |
| try (final ClassicHttpResponse response1 = endpoint1.execute("id1", request, exec, context)) { |
| Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); |
| } |
| |
| // check that there is no auto-release by default |
| final LeaseRequest leaseRequest2 = connManager.lease("id2", route, null); |
| // this should fail quickly, connection has not been released |
| Assertions.assertThrows(TimeoutException.class, () -> leaseRequest2.get(Timeout.ofMilliseconds(10))); |
| |
| endpoint1.close(); |
| connManager.release(endpoint1, null, TimeValue.ofMilliseconds(100)); |
| |
| final LeaseRequest leaseRequest3 = connManager.lease("id2", route, null); |
| final ConnectionEndpoint endpoint2 = leaseRequest3.get(Timeout.ZERO_MILLISECONDS); |
| Assertions.assertFalse(endpoint2.isConnected()); |
| |
| connManager.connect(endpoint2, null, context); |
| |
| try (final ClassicHttpResponse response2 = endpoint2.execute("id2", request, exec, context)) { |
| Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); |
| } |
| |
| connManager.release(endpoint2, null, TimeValue.ofMilliseconds(100)); |
| |
| final LeaseRequest leaseRequest4 = connManager.lease("id3", route, null); |
| final ConnectionEndpoint endpoint3 = leaseRequest4.get(Timeout.ZERO_MILLISECONDS); |
| Assertions.assertTrue(endpoint3.isConnected()); |
| |
| // repeat the communication, no need to prepare the request again |
| try (final ClassicHttpResponse response3 = endpoint3.execute("id3", request, exec, context)) { |
| Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); |
| } |
| |
| connManager.release(endpoint3, null, TimeValue.ofMilliseconds(100)); |
| Thread.sleep(150); |
| |
| final LeaseRequest leaseRequest5 = connManager.lease("id4", route, null); |
| final ConnectionEndpoint endpoint4 = leaseRequest5.get(Timeout.ZERO_MILLISECONDS); |
| Assertions.assertFalse(endpoint4.isConnected()); |
| |
| // repeat the communication, no need to prepare the request again |
| connManager.connect(endpoint4, null, context); |
| |
| try (final ClassicHttpResponse response4 = endpoint4.execute("id4", request, exec, context)) { |
| Assertions.assertEquals(HttpStatus.SC_OK, response4.getCode()); |
| } |
| |
| connManager.close(); |
| } |
| |
| @Test |
| public void testCloseExpiredIdleConnections() throws Exception { |
| startServer(); |
| final HttpHost target = targetHost(); |
| startClient(); |
| |
| final PoolingHttpClientConnectionManager connManager = testResources.connManager(); |
| connManager.setMaxTotal(1); |
| |
| final HttpRoute route = new HttpRoute(target, null, false); |
| final HttpClientContext context = HttpClientContext.create(); |
| |
| final LeaseRequest leaseRequest1 = connManager.lease("id1", route, null); |
| final ConnectionEndpoint endpoint1 = leaseRequest1.get(Timeout.ZERO_MILLISECONDS); |
| connManager.connect(endpoint1, null, context); |
| |
| Assertions.assertEquals(1, connManager.getTotalStats().getLeased()); |
| Assertions.assertEquals(1, connManager.getStats(route).getLeased()); |
| |
| connManager.release(endpoint1, null, TimeValue.ofMilliseconds(100)); |
| |
| // Released, still active. |
| Assertions.assertEquals(1, connManager.getTotalStats().getAvailable()); |
| Assertions.assertEquals(1, connManager.getStats(route).getAvailable()); |
| |
| connManager.closeExpired(); |
| |
| // Time has not expired yet. |
| Assertions.assertEquals(1, connManager.getTotalStats().getAvailable()); |
| Assertions.assertEquals(1, connManager.getStats(route).getAvailable()); |
| |
| Thread.sleep(150); |
| |
| connManager.closeExpired(); |
| |
| // Time expired now, connections are destroyed. |
| Assertions.assertEquals(0, connManager.getTotalStats().getAvailable()); |
| Assertions.assertEquals(0, connManager.getStats(route).getAvailable()); |
| |
| connManager.close(); |
| } |
| |
| @Test |
| public void testCloseExpiredTTLConnections() throws Exception { |
| final ClassicTestServer server = startServer(); |
| server.registerHandler("/random/*", new RandomHandler()); |
| final HttpHost target = targetHost(); |
| |
| testResources.startClient( |
| builder -> builder |
| .setPoolConcurrencyPolicy(PoolConcurrencyPolicy.STRICT) |
| .setConnPoolPolicy(PoolReusePolicy.LIFO) |
| .setDefaultConnectionConfig(ConnectionConfig.custom() |
| .setTimeToLive(TimeValue.ofMilliseconds(100)) |
| .build()) |
| .setMaxConnTotal(1), |
| builder -> {} |
| ); |
| |
| final PoolingHttpClientConnectionManager connManager = testResources.connManager(); |
| connManager.setMaxTotal(1); |
| |
| final HttpRoute route = new HttpRoute(target, null, false); |
| final HttpClientContext context = HttpClientContext.create(); |
| |
| final LeaseRequest leaseRequest1 = connManager.lease("id1", route, null); |
| final ConnectionEndpoint endpoint1 = leaseRequest1.get(Timeout.ZERO_MILLISECONDS); |
| connManager.connect(endpoint1, null, context); |
| |
| Assertions.assertEquals(1, connManager.getTotalStats().getLeased()); |
| Assertions.assertEquals(1, connManager.getStats(route).getLeased()); |
| // Release, let remain idle for forever |
| connManager.release(endpoint1, null, TimeValue.NEG_ONE_MILLISECOND); |
| |
| // Released, still active. |
| Assertions.assertEquals(1, connManager.getTotalStats().getAvailable()); |
| Assertions.assertEquals(1, connManager.getStats(route).getAvailable()); |
| |
| connManager.closeExpired(); |
| |
| // Time has not expired yet. |
| Assertions.assertEquals(1, connManager.getTotalStats().getAvailable()); |
| Assertions.assertEquals(1, connManager.getStats(route).getAvailable()); |
| |
| Thread.sleep(150); |
| |
| connManager.closeExpired(); |
| |
| // TTL expired now, connections are destroyed. |
| Assertions.assertEquals(0, connManager.getTotalStats().getAvailable()); |
| Assertions.assertEquals(0, connManager.getStats(route).getAvailable()); |
| |
| connManager.close(); |
| } |
| |
| } |