AbstractConnectTimeoutHandshake.java

/*
 * Copyright (c) 2018, 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.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URI;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.net.http.HttpClient;
import java.net.http.HttpClient.Version;
import java.net.http.HttpConnectTimeoutException;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.DataProvider;
import static java.lang.String.format;
import static java.lang.System.out;
import static java.net.http.HttpClient.Builder.NO_PROXY;
import static java.net.http.HttpClient.Version.HTTP_1_1;
import static java.net.http.HttpClient.Version.HTTP_2;
import static java.time.Duration.*;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static org.testng.Assert.fail;

public abstract class AbstractConnectTimeoutHandshake {

    // The number of iterations each testXXXClient performs.
    static final int TIMES = 2;

    Server server;
    URI httpsURI;

    static final Duration NO_DURATION = null;

    static List<List<Duration>> TIMEOUTS = List.of(
                    // connectTimeout   HttpRequest timeout
            Arrays.asList( NO_DURATION,   ofSeconds(1)  ),
            Arrays.asList( NO_DURATION,   ofSeconds(2)  ),
            Arrays.asList( NO_DURATION,   ofMillis(500) ),

            Arrays.asList( ofSeconds(1),  NO_DURATION   ),
            Arrays.asList( ofSeconds(2),  NO_DURATION   ),
            Arrays.asList( ofMillis(500), NO_DURATION   ),

            Arrays.asList( ofSeconds(1),  ofMinutes(1)  ),
            Arrays.asList( ofSeconds(2),  ofMinutes(1)  ),
            Arrays.asList( ofMillis(500), ofMinutes(1)  )
    );

    static final List<String> METHODS = List.of("GET" , "POST");
    static final List<Version> VERSIONS = List.of(HTTP_2, HTTP_1_1);

    @DataProvider(name = "variants")
    public Object[][] variants() {
        List<Object[]> l = new ArrayList<>();
        for (List<Duration> timeouts : TIMEOUTS) {
           Duration connectTimeout = timeouts.get(0);
           Duration requestTimeout = timeouts.get(1);
           for (String method: METHODS) {
            for (Version requestVersion : VERSIONS) {
             l.add(new Object[] {requestVersion, method, connectTimeout, requestTimeout});
        }}}
        return l.stream().toArray(Object[][]::new);
    }

    //@Test(dataProvider = "variants")
    protected void timeoutSync(Version requestVersion,
                              String method,
                              Duration connectTimeout,
                              Duration requestTimeout)
        throws Exception
    {
        out.printf("%n--- timeoutSync requestVersion=%s, method=%s, "
                   + "connectTimeout=%s, requestTimeout=%s ---%n",
                   requestVersion, method, connectTimeout, requestTimeout);
        HttpClient client = newClient(connectTimeout);
        HttpRequest request = newRequest(requestVersion, method, requestTimeout);

        for (int i = 0; i < TIMES; i++) {
            out.printf("iteration %d%n", i);
            long startTime = System.nanoTime();
            try {
                HttpResponse<String> resp = client.send(request, BodyHandlers.ofString());
                printResponse(resp);
                fail("Unexpected response: " + resp);
            } catch (HttpConnectTimeoutException expected) {
                long elapsedTime = NANOSECONDS.toMillis(System.nanoTime() - startTime);
                out.printf("Client: received in %d millis%n", elapsedTime);
                out.printf("Client: caught expected HttpConnectTimeoutException: %s%n", expected);
                checkExceptionOrCause(ConnectException.class, expected);
            }
        }
    }

    //@Test(dataProvider = "variants")
    protected void timeoutAsync(Version requestVersion,
                                String method,
                                Duration connectTimeout,
                                Duration requestTimeout) {
        out.printf("%n--- timeoutAsync requestVersion=%s, method=%s, "
                        + "connectTimeout=%s, requestTimeout=%s ---%n",
                   requestVersion, method, connectTimeout, requestTimeout);
        HttpClient client = newClient(connectTimeout);
        HttpRequest request = newRequest(requestVersion, method, requestTimeout);

        for (int i = 0; i < TIMES; i++) {
            out.printf("iteration %d%n", i);
            long startTime = System.nanoTime();
            CompletableFuture<HttpResponse<String>> cf =
                    client.sendAsync(request, BodyHandlers.ofString());
            try {
                HttpResponse<String> resp = cf.join();
                printResponse(resp);
                fail("Unexpected response: " + resp);
            } catch (CompletionException ce) {
                long elapsedTime = NANOSECONDS.toMillis(System.nanoTime() - startTime);
                out.printf("Client: received in %d millis%n", elapsedTime);
                Throwable expected = ce.getCause();
                if (expected instanceof HttpConnectTimeoutException) {
                    out.printf("Client: caught expected HttpConnectTimeoutException: %s%n", expected);
                    checkExceptionOrCause(ConnectException.class, expected);
                } else {
                    out.printf("Client: caught UNEXPECTED exception: %s%n", expected);
                    throw ce;
                }
            }
        }
    }

    static HttpClient newClient(Duration connectTimeout) {
        HttpClient.Builder builder = HttpClient.newBuilder().proxy(NO_PROXY);
        if (connectTimeout != NO_DURATION)
            builder.connectTimeout(connectTimeout);
        return builder.build();
    }

    HttpRequest newRequest(Version reqVersion,
                           String method,
                           Duration requestTimeout) {
        HttpRequest.Builder reqBuilder = HttpRequest.newBuilder(httpsURI);
        reqBuilder = reqBuilder.version(reqVersion);
        switch (method) {
            case "GET"   : reqBuilder.GET();                         break;
            case "POST"  : reqBuilder.POST(BodyPublishers.noBody()); break;
            default: throw new AssertionError("Unknown method:" + method);
        }
        if (requestTimeout != NO_DURATION)
            reqBuilder.timeout(requestTimeout);
        return reqBuilder.build();
    }

    static void checkExceptionOrCause(Class<? extends Throwable> clazz, Throwable t) {
        final Throwable original = t;
        do {
            if (clazz.isInstance(t)) {
                System.out.println("Found expected exception/cause: " + t);
                return; // found
            }
        } while ((t = t.getCause()) != null);
        original.printStackTrace(System.out);
        throw new RuntimeException("Expected " + clazz + "in " + original);
    }

    static void printResponse(HttpResponse<?> response) {
        out.println("Unexpected response: " + response);
        out.println("Headers: " + response.headers());
        out.println("Body: " + response.body());
    }

    // -- Infrastructure

    static String serverAuthority(Server server) {
        return InetAddress.getLoopbackAddress().getHostName() + ":"
                + server.getPort();
    }

    @BeforeTest
    public void setup() throws Exception {
        server = new Server();
        httpsURI = URI.create("https://" + serverAuthority(server) + "/foo");
        out.println("HTTPS URI: " + httpsURI);
    }

    @AfterTest
    public void teardown() throws Exception {
        server.close();
        out.printf("%n--- teardown ---%n");

        int numClientConnections = variants().length * TIMES;
        int serverCount = server.count;
        out.printf("Client made %d connections.%n", numClientConnections);
        out.printf("Server received %d connections.%n", serverCount);

        // This is usually the case, but not always, do not assert. Remains
        // as an informative message only.
        //if (numClientConnections != serverCount)
        //    fail(format("[numTests: %d] != [serverCount: %d]",
        //                numClientConnections, serverCount));
    }

    /**
     * Emulates a server-side, using plain cleartext Sockets, that just reads
     * initial client hello and does nothing more.
     */
    static class Server extends Thread implements AutoCloseable {
        private final ServerSocket ss;
        private volatile boolean closed;
        volatile int count;

        Server() throws IOException {
            super("Server");
            ss = new ServerSocket();
            ss.setReuseAddress(false);
            ss.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));
            this.start();
        }

        int getPort() {
            return ss.getLocalPort();
        }

        @Override
        public void close() {
            if (closed)
                return;
            closed = true;
            try {
                ss.close();
            } catch (IOException e) {
                throw new UncheckedIOException("Unexpected", e);
            }
        }

        @Override
        public void run() {
            while (!closed) {
                try (Socket s = ss.accept()) {
                    count++;
                    out.println("Server: accepted new connection");
                    InputStream is = new BufferedInputStream(s.getInputStream());

                    out.println("Server: starting to read");
                    while (is.read() != -1) ;

                    out.println("Server: closing connection");
                    s.close(); // close without giving any reply
                } catch (IOException e) {
                    if (!closed)
                        out.println("UNEXPECTED " + e);
                }
            }
        }
    }
}