184 lines
8.2 KiB
Java
184 lines
8.2 KiB
Java
/*
|
|
* Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.net.InetSocketAddress;
|
|
import java.net.URI;
|
|
import java.net.http.HttpClient;
|
|
import java.net.http.HttpRequest;
|
|
import java.net.http.HttpResponse;
|
|
import java.net.http.HttpResponse.BodyHandlers;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.stream.Stream;
|
|
|
|
import javax.net.ssl.SSLContext;
|
|
|
|
import jdk.httpclient.test.lib.common.HttpServerAdapters.HttpTestExchange;
|
|
import jdk.httpclient.test.lib.common.HttpServerAdapters.HttpTestHandler;
|
|
import jdk.httpclient.test.lib.common.HttpServerAdapters.HttpTestServer;
|
|
import jdk.test.lib.net.IPSupport;
|
|
import jdk.test.lib.net.SimpleSSLContext;
|
|
import org.junit.jupiter.api.AfterAll;
|
|
import org.junit.jupiter.api.Assumptions;
|
|
import org.junit.jupiter.api.BeforeAll;
|
|
import org.junit.jupiter.params.ParameterizedTest;
|
|
import org.junit.jupiter.params.provider.Arguments;
|
|
import org.junit.jupiter.params.provider.MethodSource;
|
|
import static java.net.http.HttpClient.Builder.NO_PROXY;
|
|
import static java.net.http.HttpClient.Version.HTTP_2;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertNotEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8305906
|
|
* @summary verify that the HttpClient pools and reuses a connection for HTTP/2 requests
|
|
* @library /test/lib /test/jdk/java/net/httpclient/lib
|
|
* @build jdk.test.lib.net.SimpleSSLContext
|
|
* jdk.test.lib.net.IPSupport
|
|
* jdk.httpclient.test.lib.common.HttpServerAdapters
|
|
*
|
|
* @run junit ConnectionReuseTest
|
|
* @run junit/othervm -Djava.net.preferIPv6Addresses=true
|
|
* -Djdk.internal.httpclient.debug=true ConnectionReuseTest
|
|
*/
|
|
public class ConnectionReuseTest {
|
|
|
|
private static SSLContext sslContext;
|
|
private static HttpTestServer http2_Server; // h2 server over HTTP
|
|
private static HttpTestServer https2_Server; // h2 server over HTTPS
|
|
|
|
@BeforeAll
|
|
public static void beforeAll() throws Exception {
|
|
if (IPSupport.preferIPv6Addresses()) {
|
|
IPSupport.printPlatformSupport(System.err); // for debug purposes
|
|
// this test is run with -Djava.net.preferIPv6Addresses=true, so skip (all) tests
|
|
// if IPv6 isn't supported on this host
|
|
Assumptions.assumeTrue(IPSupport.hasIPv6(), "Skipping tests - IPv6 is not supported");
|
|
}
|
|
sslContext = new SimpleSSLContext().get();
|
|
assertNotNull(sslContext, "Unexpected null sslContext");
|
|
|
|
http2_Server = HttpTestServer.create(HTTP_2);
|
|
http2_Server.addHandler(new Handler(), "/");
|
|
http2_Server.start();
|
|
System.out.println("Started HTTP v2 server at " + http2_Server.serverAuthority());
|
|
|
|
https2_Server = HttpTestServer.create(HTTP_2, sslContext);
|
|
https2_Server.addHandler(new Handler(), "/");
|
|
https2_Server.start();
|
|
System.out.println("Started HTTPS v2 server at " + https2_Server.serverAuthority());
|
|
}
|
|
|
|
@AfterAll
|
|
public static void afterAll() {
|
|
if (https2_Server != null) {
|
|
System.out.println("Stopping server " + https2_Server);
|
|
https2_Server.stop();
|
|
}
|
|
if (http2_Server != null) {
|
|
System.out.println("Stopping server " + http2_Server);
|
|
http2_Server.stop();
|
|
}
|
|
}
|
|
|
|
private static Stream<Arguments> requestURIs() throws Exception {
|
|
final List<Arguments> arguments = new ArrayList<>();
|
|
// h2 over HTTPS
|
|
arguments.add(Arguments.of(new URI("https://" + https2_Server.serverAuthority() + "/")));
|
|
// h2 over HTTP
|
|
arguments.add(Arguments.of(new URI("http://" + http2_Server.serverAuthority() + "/")));
|
|
if (IPSupport.preferIPv6Addresses()) {
|
|
if (https2_Server.getAddress().getAddress().isLoopbackAddress()) {
|
|
// h2 over HTTPS, use the short form of the host, in the request URI
|
|
arguments.add(Arguments.of(new URI("https://[::1]:" +
|
|
https2_Server.getAddress().getPort() + "/")));
|
|
}
|
|
if (http2_Server.getAddress().getAddress().isLoopbackAddress()) {
|
|
// h2 over HTTP, use the short form of the host, in the request URI
|
|
arguments.add(Arguments.of(new URI("http://[::1]:" +
|
|
http2_Server.getAddress().getPort() + "/")));
|
|
}
|
|
}
|
|
return arguments.stream();
|
|
}
|
|
|
|
/**
|
|
* Uses a single instance of a HttpClient and issues multiple requests to {@code requestURI}
|
|
* and expects that each of the request internally uses the same connection
|
|
*/
|
|
@ParameterizedTest
|
|
@MethodSource("requestURIs")
|
|
public void testConnReuse(final URI requestURI) throws Exception {
|
|
final HttpClient.Builder builder = HttpClient.newBuilder()
|
|
.proxy(NO_PROXY).sslContext(sslContext);
|
|
final HttpRequest req = HttpRequest.newBuilder().uri(requestURI)
|
|
.GET().version(HTTP_2).build();
|
|
try (final HttpClient client = builder.build()) {
|
|
String clientConnAddr = null;
|
|
for (int i = 1; i <= 5; i++) {
|
|
System.out.println("Issuing request(" + i + ") " + req);
|
|
final HttpResponse<String> resp = client.send(req, BodyHandlers.ofString());
|
|
assertEquals(200, resp.statusCode(), "unexpected response code");
|
|
final String respBody = resp.body();
|
|
System.out.println("Server side handler responded to a request from " + respBody);
|
|
assertNotEquals(Handler.UNKNOWN_CLIENT_ADDR, respBody,
|
|
"server handler couldn't determine client address in request");
|
|
if (i == 1) {
|
|
// for the first request we just keep track of the client connection address
|
|
// that got used for this request
|
|
clientConnAddr = respBody;
|
|
} else {
|
|
// verify that the client connection used to issue the request is the same
|
|
// as the previous request's client connection
|
|
assertEquals(clientConnAddr, respBody, "HttpClient unexpectedly used a" +
|
|
" different connection for request(" + i + ")");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static final class Handler implements HttpTestHandler {
|
|
|
|
private static final String UNKNOWN_CLIENT_ADDR = "unknown";
|
|
|
|
@Override
|
|
public void handle(final HttpTestExchange t) throws IOException {
|
|
final InetSocketAddress clientAddr = t.getRemoteAddress();
|
|
System.out.println("Handling request " + t.getRequestURI() + " from " + clientAddr);
|
|
// we write out the client address into the response body
|
|
final byte[] responseBody = clientAddr == null
|
|
? UNKNOWN_CLIENT_ADDR.getBytes(StandardCharsets.UTF_8)
|
|
: clientAddr.toString().getBytes(StandardCharsets.UTF_8);
|
|
t.sendResponseHeaders(200, responseBody.length);
|
|
try (final OutputStream os = t.getResponseBody()) {
|
|
os.write(responseBody);
|
|
}
|
|
}
|
|
}
|
|
}
|