8164625: Pooled HttpConnection should be removed during close

Reviewed-by: dfuchs, michaelm

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Exchange.java

@@ -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() {

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/ExchangeImpl.java

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

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Http1Exchange.java

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

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Http1Response.java

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

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/HttpConnection.java

@@ -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,

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/HttpRequestImpl.java

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

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/PlainTunnelingConnection.java

@@ -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 {
 

jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/Stream.java

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

jdk/test/java/net/httpclient/HandshakePhase.java

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

jdk/test/java/net/httpclient/websocket/ConnectionHandover.java

@@ -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) { }
+        }
+    }
+}

jdk/test/java/net/httpclient/websocket/DummyWebSocketServer.java

@@ -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) { }
+        }
+    }
+}

jdk/test/java/net/httpclient/websocket/LoggingHelper.java

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

jdk/test/java/net/httpclient/websocket/logging.properties

@@ -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