1berry/openjdk
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

8164625: Pooled HttpConnection should be removed during close

Browse Source 
Reviewed-by: dfuchs, michaelm
This commit is contained in:
Pavel Rappo 2017-02-24 17:05:00 +00:00
parent 8ebfe2c58b
commit 191aad0e62
13 changed files with 413 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Exchange.java
View File

@ -133,11 +133,13 @@ final class Exchange<T> {
}
public T readBody(HttpResponse.BodyHandler<T> responseHandler) throws IOException {
return exchImpl.readBody(responseHandler, true);
// The connection will not be returned to the pool in the case of WebSocket
return exchImpl.readBody(responseHandler, !request.isWebSocket());
}
public CompletableFuture<T> readBodyAsync(HttpResponse.BodyHandler<T> handler) {
return exchImpl.readBodyAsync(handler, true, parentExecutor);
// The connection will not be returned to the pool in the case of WebSocket
return exchImpl.readBodyAsync(handler, !request.isWebSocket(), parentExecutor);
}
public void cancel() {

6
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/ExchangeImpl.java
View File

@ -117,11 +117,11 @@ abstract class ExchangeImpl<T> {
*/
abstract Response getResponse() throws IOException;
abstract T readBody(HttpResponse.BodyHandler<T> handler, boolean returnToCache)
throws IOException;
abstract T readBody(HttpResponse.BodyHandler<T> handler,
boolean returnConnectionToPool) throws IOException;
abstract CompletableFuture<T> readBodyAsync(HttpResponse.BodyHandler<T> handler,
boolean returnToCache,
boolean returnConnectionToPool,
Executor executor);
// Builtin processors need access to HttpClientImpl

8
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Http1Exchange.java
View File

@ -88,14 +88,14 @@ class Http1Exchange<T> extends ExchangeImpl<T> {
@Override
T readBody(BodyHandler<T> handler, boolean returnToCache)
T readBody(BodyHandler<T> handler, boolean returnConnectionToPool)
throws IOException
{
BodyProcessor<T> processor = handler.apply(response.responseCode(),
response.responseHeaders());
setClientForResponse(processor);
CompletableFuture<T> bodyCF = response.readBody(processor,
returnToCache,
returnConnectionToPool,
this::executeInline);
try {
return bodyCF.join();
@ -114,14 +114,14 @@ class Http1Exchange<T> extends ExchangeImpl<T> {
@Override
CompletableFuture<T> readBodyAsync(BodyHandler<T> handler,
boolean returnToCache,
boolean returnConnectionToPool,
Executor executor)
{
BodyProcessor<T> processor = handler.apply(response.responseCode(),
response.responseHeaders());
setClientForResponse(processor);
CompletableFuture<T> bodyCF = response.readBody(processor,
returnToCache,
returnConnectionToPool,
executor);
return bodyCF;
}

1
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Http1Response.java
View File

@ -164,6 +164,7 @@ class Http1Response<T> {
private void onFinished() {
if (return2Cache) {
Log.logTrace("Returning connection to the pool: {0}", connection);
connection.returnToCache(headers);
}
}

2
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/HttpConnection.java
View File

@ -115,7 +115,7 @@ abstract class HttpConnection implements Closeable {
}
/* Returns either a plain HTTP connection or a plain tunnelling connection
* for proxied websockets */
* for proxied WebSocket */
private static HttpConnection getPlainConnection(InetSocketAddress addr,
InetSocketAddress proxy,
HttpRequestImpl request,

5
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/HttpRequestImpl.java
View File

@ -81,6 +81,7 @@ class HttpRequestImpl extends HttpRequest implements WebSocketRequest {
this.userHeaders = request.headers();
if (request instanceof HttpRequestImpl) {
this.systemHeaders = ((HttpRequestImpl) request).systemHeaders;
this.isWebSocket = ((HttpRequestImpl) request).isWebSocket;
} else {
this.systemHeaders = new HttpHeadersImpl();
}
@ -102,6 +103,7 @@ class HttpRequestImpl extends HttpRequest implements WebSocketRequest {
HttpRequestImpl other) {
this.method = method == null? "GET" : method;
this.userHeaders = other.userHeaders;
this.isWebSocket = other.isWebSocket;
this.systemHeaders = other.systemHeaders;
this.uri = uri;
this.expectContinue = other.expectContinue;
@ -115,6 +117,9 @@ class HttpRequestImpl extends HttpRequest implements WebSocketRequest {
/* used for creating CONNECT requests */
HttpRequestImpl(String method, HttpClientImpl client,
InetSocketAddress authority) {
// TODO: isWebSocket flag is not specified, but the assumption is that
// such a request will never be made on a connection that will be returned
// to the connection pool (we might need to revisit this constructor later)
this.method = method;
this.systemHeaders = new HttpHeadersImpl();
this.userHeaders = ImmutableHeaders.empty();

2
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/PlainTunnelingConnection.java
View File

@ -36,7 +36,7 @@ import java.util.concurrent.CompletableFuture;
/**
* A plain text socket tunnel through a proxy. Uses "CONNECT" but does not
* encrypt. Used by WebSockets. Subclassed in SSLTunnelConnection for encryption.
* encrypt. Used by WebSocket. Subclassed in SSLTunnelConnection for encryption.
*/
class PlainTunnelingConnection extends HttpConnection {

10
jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Stream.java
View File

@ -148,7 +148,7 @@ class Stream<T> extends ExchangeImpl<T> {
@Override
CompletableFuture<T> readBodyAsync(HttpResponse.BodyHandler<T> handler,
boolean returnToCache,
boolean returnConnectionToPool,
Executor executor)
{
Log.logTrace("Reading body on stream {0}", streamid);
@ -166,11 +166,11 @@ class Stream<T> extends ExchangeImpl<T> {
}
@Override
T readBody(HttpResponse.BodyHandler<T> handler, boolean returnToCache)
T readBody(HttpResponse.BodyHandler<T> handler, boolean returnConnectionToPool)
throws IOException
{
CompletableFuture<T> cf = readBodyAsync(handler,
returnToCache,
returnConnectionToPool,
null);
try {
return cf.join();
@ -871,10 +871,10 @@ class Stream<T> extends ExchangeImpl<T> {
@Override
CompletableFuture<T> readBodyAsync(
HttpResponse.BodyHandler<T> handler,
boolean returnToCache,
boolean returnConnectionToPool,
Executor executor)
{
return super.readBodyAsync(handler, returnToCache, executor)
return super.readBodyAsync(handler, returnConnectionToPool, executor)
.whenComplete((v, t) -> pushGroup.pushError(t));
}

265
jdk/test/java/net/httpclient/HandshakePhase.java
View File

@ -1,265 +0,0 @@
/*
* Copyright (c) 2016, 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.UncheckedIOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import static java.lang.String.format;
import static java.util.Objects.requireNonNull;
//
// Performs a simple opening handshake and yields the channel.
//
// Client Request:
//
// GET /chat HTTP/1.1
// Host: server.example.com
// Upgrade: websocket
// Connection: Upgrade
// Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
// Origin: http://example.com
// Sec-WebSocket-Protocol: chat, superchat
// Sec-WebSocket-Version: 13
//
//
// Server Response:
//
// HTTP/1.1 101 Switching Protocols
// Upgrade: websocket
// Connection: Upgrade
// Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
// Sec-WebSocket-Protocol: chat
//
final class HandshakePhase {
private final ServerSocketChannel ssc;
HandshakePhase(InetSocketAddress address) {
requireNonNull(address);
try {
ssc = ServerSocketChannel.open();
ssc.bind(address);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
//
// Returned CF completes normally after the handshake has been performed
//
CompletableFuture<SocketChannel> afterHandshake(
Function<List<String>, List<String>> mapping) {
return CompletableFuture.supplyAsync(
() -> {
SocketChannel socketChannel = accept();
try {
StringBuilder request = new StringBuilder();
if (!readRequest(socketChannel, request)) {
throw new IllegalStateException();
}
List<String> strings = Arrays.asList(
request.toString().split("\r\n")
);
List<String> response = mapping.apply(strings);
writeResponse(socketChannel, response);
return socketChannel;
} catch (Throwable t) {
try {
socketChannel.close();
} catch (IOException ignored) { }
throw t;
}
});
}
CompletableFuture<SocketChannel> afterHandshake() {
return afterHandshake((request) -> {
List<String> response = new LinkedList<>();
Iterator<String> iterator = request.iterator();
if (!iterator.hasNext()) {
throw new IllegalStateException("The request is empty");
}
if (!"GET / HTTP/1.1".equals(iterator.next())) {
throw new IllegalStateException
("Unexpected status line: " + request.get(0));
}
response.add("HTTP/1.1 101 Switching Protocols");
Map<String, String> requestHeaders = new HashMap<>();
while (iterator.hasNext()) {
String header = iterator.next();
String[] split = header.split(": ");
if (split.length != 2) {
throw new IllegalStateException
("Unexpected header: " + header
+ ", split=" + Arrays.toString(split));
}
if (requestHeaders.put(split[0], split[1]) != null) {
throw new IllegalStateException
("Duplicating headers: " + Arrays.toString(split));
}
}
if (requestHeaders.containsKey("Sec-WebSocket-Protocol")) {
throw new IllegalStateException("Subprotocols are not expected");
}
if (requestHeaders.containsKey("Sec-WebSocket-Extensions")) {
throw new IllegalStateException("Extensions are not expected");
}
expectHeader(requestHeaders, "Connection", "Upgrade");
response.add("Connection: Upgrade");
expectHeader(requestHeaders, "Upgrade", "websocket");
response.add("Upgrade: websocket");
expectHeader(requestHeaders, "Sec-WebSocket-Version", "13");
String key = requestHeaders.get("Sec-WebSocket-Key");
if (key == null) {
throw new IllegalStateException("Sec-WebSocket-Key is missing");
}
MessageDigest sha1 = null;
try {
sha1 = MessageDigest.getInstance("SHA-1");
} catch (NoSuchAlgorithmException e) {
throw new InternalError(e);
}
String x = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
sha1.update(x.getBytes(StandardCharsets.ISO_8859_1));
String v = Base64.getEncoder().encodeToString(sha1.digest());
response.add("Sec-WebSocket-Accept: " + v);
return response;
});
}
private String expectHeader(Map<String, String> headers,
String name,
String value) {
String v = headers.get(name);
if (!value.equals(v)) {
throw new IllegalStateException(
format("Expected '%s: %s', actual: '%s: %s'",
name, value, name, v)
);
}
return v;
}
URI getURI() {
InetSocketAddress a;
try {
a = (InetSocketAddress) ssc.getLocalAddress();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
return URI.create("ws://" + a.getHostName() + ":" + a.getPort());
}
private int read(SocketChannel socketChannel, ByteBuffer buffer) {
try {
int num = socketChannel.read(buffer);
if (num == -1) {
throw new IllegalStateException("Unexpected EOF");
}
assert socketChannel.isBlocking() && num > 0;
return num;
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
private SocketChannel accept() {
SocketChannel socketChannel = null;
try {
socketChannel = ssc.accept();
socketChannel.configureBlocking(true);
} catch (IOException e) {
if (socketChannel != null) {
try {
socketChannel.close();
} catch (IOException ignored) { }
}
throw new UncheckedIOException(e);
}
return socketChannel;
}
private boolean readRequest(SocketChannel socketChannel,
StringBuilder request) {
ByteBuffer buffer = ByteBuffer.allocateDirect(512);
read(socketChannel, buffer);
CharBuffer decoded;
buffer.flip();
try {
decoded =
StandardCharsets.ISO_8859_1.newDecoder().decode(buffer);
} catch (CharacterCodingException e) {
throw new UncheckedIOException(e);
}
request.append(decoded);
return Pattern.compile("\r\n\r\n").matcher(request).find();
}
private void writeResponse(SocketChannel socketChannel,
List<String> response) {
String s = response.stream().collect(Collectors.joining("\r\n"))
+ "\r\n\r\n";
ByteBuffer encoded;
try {
encoded =
StandardCharsets.ISO_8859_1.newEncoder().encode(CharBuffer.wrap(s));
} catch (CharacterCodingException e) {
throw new UncheckedIOException(e);
}
write(socketChannel, encoded);
}
private void write(SocketChannel socketChannel, ByteBuffer buffer) {
try {
while (buffer.hasRemaining()) {
socketChannel.write(buffer);
}
} catch (IOException e) {
try {
socketChannel.close();
} catch (IOException ignored) { }
throw new UncheckedIOException(e);
}
}
}

68
jdk/test/java/net/httpclient/websocket/ConnectionHandover.java Normal file
View File

@ -0,0 +1,68 @@
/*
* Copyright (c) 2017, 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 jdk.incubator.http.HttpClient;
import jdk.incubator.http.WebSocket;
import java.io.IOException;
import java.net.URI;
/*
* @test
* @bug 8164625
* @summary Verifies HttpClient yields the connection to the WebSocket
* @run main/othervm -Djdk.httpclient.HttpClient.log=trace ConnectionHandover
*/
public class ConnectionHandover {
static {
LoggingHelper.setupLogging();
}
/*
* An I/O channel associated with the connection is closed by WebSocket.abort().
* If this connection is returned to the connection pool, then the second
* attempt to use it would fail with a ClosedChannelException.
*
* The assumption is that since the WebSocket client is connecting to the
* same URI, the pooled connection is to be used.
*/
public static void main(String[] args) throws IOException {
try (DummyWebSocketServer server = new DummyWebSocketServer()) {
server.open();
URI uri = server.getURI();
WebSocket.Builder webSocketBuilder =
HttpClient.newHttpClient().newWebSocketBuilder(uri, new WebSocket.Listener() { });
WebSocket ws1 = webSocketBuilder.buildAsync().join();
try {
ws1.abort();
} catch (IOException ignored) { }
WebSocket ws2 = webSocketBuilder.buildAsync().join(); // Exception here if the connection was pooled
try {
ws2.abort();
} catch (IOException ignored) { }
}
}
}

278
jdk/test/java/net/httpclient/websocket/DummyWebSocketServer.java Normal file
View File

@ -0,0 +1,278 @@
/*
* Copyright (c) 2016, 2017, 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.Closeable;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ClosedByInterruptException;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.CharacterCodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import static java.lang.String.format;
import static java.lang.System.Logger.Level.ERROR;
import static java.lang.System.Logger.Level.INFO;
import static java.lang.System.Logger.Level.TRACE;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static java.util.Arrays.asList;
import static java.util.Objects.requireNonNull;
/**
* Dummy WebSocket Server.
*
* Performs simpler version of the WebSocket Opening Handshake over HTTP (i.e.
* no proxying, cookies, etc.) Supports sequential connections, one at a time,
* i.e. in order for a client to connect to the server the previous client must
* disconnect first.
*
* Expected client request:
*
* GET /chat HTTP/1.1
* Host: server.example.com
* Upgrade: websocket
* Connection: Upgrade
* Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
* Origin: http://example.com
* Sec-WebSocket-Protocol: chat, superchat
* Sec-WebSocket-Version: 13
*
* This server response:
*
* HTTP/1.1 101 Switching Protocols
* Upgrade: websocket
* Connection: Upgrade
* Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
* Sec-WebSocket-Protocol: chat
*/
public final class DummyWebSocketServer implements Closeable {
private final static System.Logger log = System.getLogger(DummyWebSocketServer.class.getName());
private final AtomicBoolean started = new AtomicBoolean();
private final Thread thread;
private volatile ServerSocketChannel ssc;
private volatile InetSocketAddress address;
public DummyWebSocketServer() {
this(defaultMapping());
}
public DummyWebSocketServer(Function<List<String>, List<String>> mapping) {
requireNonNull(mapping);
thread = new Thread(() -> {
try {
while (!Thread.currentThread().isInterrupted()) {
log.log(INFO, "Accepting next connection at: " + ssc);
SocketChannel channel = ssc.accept();
log.log(INFO, "Accepted: " + channel);
try {
channel.configureBlocking(true);
StringBuilder request = new StringBuilder();
if (!readRequest(channel, request)) {
throw new IOException("Bad request");
}
List<String> strings = asList(request.toString().split("\r\n"));
List<String> response = mapping.apply(strings);
writeResponse(channel, response);
// Read until the thread is interrupted or an error occurred
// or the input is shutdown
ByteBuffer b = ByteBuffer.allocate(1024);
while (channel.read(b) != -1) {
b.clear();
}
} catch (IOException e) {
log.log(TRACE, () -> "Error in connection: " + channel, e);
} finally {
log.log(INFO, "Closed: " + channel);
close(channel);
}
}
} catch (ClosedByInterruptException ignored) {
} catch (IOException e) {
log.log(ERROR, e);
} finally {
close(ssc);
log.log(INFO, "Stopped at: " + getURI());
}
});
thread.setName("DummyWebSocketServer");
thread.setDaemon(false);
}
public void open() throws IOException {
log.log(INFO, "Starting");
if (!started.compareAndSet(false, true)) {
throw new IllegalStateException("Already started");
}
ssc = ServerSocketChannel.open();
try {
ssc.configureBlocking(true);
ssc.bind(new InetSocketAddress("localhost", 0));
address = (InetSocketAddress) ssc.getLocalAddress();
thread.start();
} catch (IOException e) {
close(ssc);
}
log.log(INFO, "Started at: " + getURI());
}
@Override
public void close() {
log.log(INFO, "Stopping: " + getURI());
thread.interrupt();
}
URI getURI() {
if (!started.get()) {
throw new IllegalStateException("Not yet started");
}
return URI.create("ws://" + address.getHostName() + ":" + address.getPort());
}
private boolean readRequest(SocketChannel channel, StringBuilder request)
throws IOException
{
ByteBuffer buffer = ByteBuffer.allocate(512);
int num = channel.read(buffer);
if (num == -1) {
return false;
}
CharBuffer decoded;
buffer.flip();
try {
decoded = ISO_8859_1.newDecoder().decode(buffer);
} catch (CharacterCodingException e) {
throw new UncheckedIOException(e);
}
request.append(decoded);
return Pattern.compile("\r\n\r\n").matcher(request).find();
}
private void writeResponse(SocketChannel channel, List<String> response)
throws IOException
{
String s = response.stream().collect(Collectors.joining("\r\n"))
+ "\r\n\r\n";
ByteBuffer encoded;
try {
encoded = ISO_8859_1.newEncoder().encode(CharBuffer.wrap(s));
} catch (CharacterCodingException e) {
throw new UncheckedIOException(e);
}
while (encoded.hasRemaining()) {
channel.write(encoded);
}
}
private static Function<List<String>, List<String>> defaultMapping() {
return request -> {
List<String> response = new LinkedList<>();
Iterator<String> iterator = request.iterator();
if (!iterator.hasNext()) {
throw new IllegalStateException("The request is empty");
}
if (!"GET / HTTP/1.1".equals(iterator.next())) {
throw new IllegalStateException
("Unexpected status line: " + request.get(0));
}
response.add("HTTP/1.1 101 Switching Protocols");
Map<String, String> requestHeaders = new HashMap<>();
while (iterator.hasNext()) {
String header = iterator.next();
String[] split = header.split(": ");
if (split.length != 2) {
throw new IllegalStateException
("Unexpected header: " + header
+ ", split=" + Arrays.toString(split));
}
if (requestHeaders.put(split[0], split[1]) != null) {
throw new IllegalStateException
("Duplicating headers: " + Arrays.toString(split));
}
}
if (requestHeaders.containsKey("Sec-WebSocket-Protocol")) {
throw new IllegalStateException("Subprotocols are not expected");
}
if (requestHeaders.containsKey("Sec-WebSocket-Extensions")) {
throw new IllegalStateException("Extensions are not expected");
}
expectHeader(requestHeaders, "Connection", "Upgrade");
response.add("Connection: Upgrade");
expectHeader(requestHeaders, "Upgrade", "websocket");
response.add("Upgrade: websocket");
expectHeader(requestHeaders, "Sec-WebSocket-Version", "13");
String key = requestHeaders.get("Sec-WebSocket-Key");
if (key == null) {
throw new IllegalStateException("Sec-WebSocket-Key is missing");
}
MessageDigest sha1 = null;
try {
sha1 = MessageDigest.getInstance("SHA-1");
} catch (NoSuchAlgorithmException e) {
throw new InternalError(e);
}
String x = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
sha1.update(x.getBytes(ISO_8859_1));
String v = Base64.getEncoder().encodeToString(sha1.digest());
response.add("Sec-WebSocket-Accept: " + v);
return response;
};
}
protected static String expectHeader(Map<String, String> headers,
String name,
String value) {
String v = headers.get(name);
if (!value.equals(v)) {
throw new IllegalStateException(
format("Expected '%s: %s', actual: '%s: %s'",
name, value, name, v)
);
}
return v;
}
private static void close(AutoCloseable... acs) {
for (AutoCloseable ac : acs) {
try {
ac.close();
} catch (Exception ignored) { }
}
}
}

38
jdk/test/java/net/httpclient/websocket/LoggingHelper.java Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright (c) 2017, 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.File;
public final class LoggingHelper {
/*
* I wish we had a support for java.util.logging in jtreg similar to what we
* have for security policy files:
*
* @run main/othervm/jul=logging.properties ClassUnderTest
*/
public static void setupLogging() {
String path = System.getProperty("test.src") + File.separator + "logging.properties";
System.setProperty("java.util.logging.config.file", path);
}
}

5
jdk/test/java/net/httpclient/websocket/logging.properties Normal file
View File

@ -0,0 +1,5 @@
handlers=java.util.logging.ConsoleHandler
.level=ALL
java.util.logging.ConsoleHandler.level=ALL
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n