BaseInteropTest.java

/*
 * Copyright (c) 2020, 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.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * The base interop test on SSL/TLS communication.
 */
public abstract class BaseInteropTest<U extends UseCase> {

    protected final Product serverProduct;
    protected final Product clientProduct;
    private static final int MAX_SERVER_RETRIES = 3;

    public BaseInteropTest(Product serverProduct, Product clientProduct) {
        this.serverProduct = serverProduct;
        this.clientProduct = clientProduct;
    }

    public boolean isJdkClient() {
        return Jdk.DEFAULT.equals(clientProduct);
    }

    /*
     * This main entrance of the test execution.
     */
    protected void execute() throws Exception {
        System.out.printf("Server: %s%nClient: %s%n",
                serverProduct, clientProduct);

        if (skipExecute()) {
            System.out.println("This execution was skipped.");
            return;
        }

        List<TestCase<U>> testCases = null;

        Path logPath = getLogPath();
        if (logPath != null) {
            System.out.println("Log: " + logPath);

            PrintStream origStdOut = System.out;
            PrintStream origStdErr = System.err;
            try (PrintStream printStream = new PrintStream(
                    new FileOutputStream(logPath.toFile()))) {
                System.setOut(printStream);
                System.setErr(printStream);

                testCases = runTest();
            } finally {
                System.setOut(origStdOut);
                System.setErr(origStdErr);
            }
        } else {
            testCases = runTest();
        }

        boolean fail = false;
        System.out.println("########## Failed Cases Start ##########");
        for (TestCase<U> testCase : testCases) {
            if (testCase.getStatus() == Status.FAIL) {
                System.out.println("--------------------");
                System.out.println(testCase);
                System.out.println("--------------------");
                fail = true;
            }
        }
        System.out.println("########## Failed Cases End ##########");

        if (fail) {
            throw new RuntimeException(
                    "At least one case failed! Please check log for details.");
        } else {
            System.out.println("This test passed!");
        }
    }

    /*
     * If either of server and client products is unavailable,
     * just skip this test execution.
     */
    protected boolean skipExecute() {
        return serverProduct.getPath() == null || clientProduct.getPath() == null;
    }

    /*
     * Returns the log path.
     * If null, no output will be redirected to local file.
     */
    protected Path getLogPath() {
        return Utilities.LOG_PATH == null
                ? null : Paths.get(Utilities.LOG_PATH);
    }

    /*
     * Provides a default set of test cases for testing.
     */
    protected abstract List<TestCase<U>> getTestCases();

    /*
     * Checks if test case should be ignored.
     */
    protected boolean ignoreTestCase(TestCase<U> testCase) {
        return false;
    }

    /*
     * Runs all test cases with the specified products as server and client
     * respectively.
     */
    protected List<TestCase<U>> runTest() throws Exception {
        List<TestCase<U>> executedTestCases = new ArrayList<>();

        List<TestCase<U>> testCases = getTestCases();
        for (TestCase<U> testCase : testCases) {
            System.out.println("========== Case Start ==========");
            System.out.println(testCase);

            if (!ignoreTestCase(testCase)) {
                Status status = runTestCase(testCase);
                testCase.setStatus(status);

                executedTestCases.add(testCase);
            } else {
                System.out.println("Ignored");
            }

            System.out.println("========== Case End ==========");
        }

        return executedTestCases;
    }

    /*
     * Runs a specific test case.
     */
    protected Status runTestCase(TestCase<U> testCase) throws Exception {
        Status serverStatus = Status.UNSTARTED;
        Status clientStatus = Status.UNSTARTED;

        ExecutorService executor = Executors.newFixedThreadPool(1);
        AbstractServer server = null;
        try {
            server = startAndGetServer(testCase.serverCase, executor);
            int port = server.getPort();
            System.out.println("Server is listening " + port);
            serverStatus = Status.PASS;

            try (AbstractClient client = createClient(testCase.clientCase)) {
                client.connect("localhost", port);
                clientStatus = Status.PASS;

                if (testCase.clientCase instanceof ExtUseCase) {
                    ExtUseCase serverCase = (ExtUseCase) testCase.serverCase;
                    ExtUseCase clientCase = (ExtUseCase) testCase.clientCase;

                    String[] clientAppProtocols = clientCase.getAppProtocols();
                        if (clientAppProtocols != null && clientAppProtocols.length > 0) {
                        String expectedNegoAppProtocol = Utilities.expectedNegoAppProtocol(
                                serverCase.getAppProtocols(),
                                clientAppProtocols);
                        System.out.println("Expected negotiated app protocol: "
                                + expectedNegoAppProtocol);
                        String negoAppProtocol = getNegoAppProtocol(server, client);
                        System.out.println(
                                "Actual negotiated app protocol: " + negoAppProtocol);
                        if (!Utilities.trimStr(negoAppProtocol).equals(
                                Utilities.trimStr(expectedNegoAppProtocol))) {
                            System.out.println(
                                    "Negotiated app protocol is unexpected");
                            clientStatus = Status.FAIL;
                        }
                    }
                }
            } catch (Exception exception) {
                clientStatus = handleClientException(exception);
            }
        } catch (Exception exception) {
            serverStatus = handleServerException(exception);
        } finally {
            if (server != null) {
                server.signalStop();
                server.close();
            }

            executor.shutdown();
        }

        Status caseStatus
                = serverStatus == Status.PASS && clientStatus == Status.PASS
                  ? Status.PASS
                  : Status.FAIL;
        System.out.printf(
                "ServerStatus=%s, ClientStatus=%s, CaseStatus=%s%n",
                serverStatus, clientStatus, caseStatus);
        return caseStatus;
    }

    /*
     * Return a server once it is properly started to avoid client connection issues.
     * Retry operation if needed, server may fail to bind a port
     */
    protected AbstractServer startAndGetServer(U useCase, ExecutorService executor)
            throws Exception {
        int maxRetries = getServerMaxRetries();
        boolean serverAlive;
        AbstractServer server;

        do {
            server = createServer(useCase, executor);
            serverAlive = Utilities.waitFor(Server::isAlive, server);
            if (!serverAlive) {
                server.signalStop();
            }

            maxRetries--;
        } while (!serverAlive && maxRetries > 0);

        if (!serverAlive) {
            throw new RuntimeException("Server failed to start");
        }

        return server;
    }

    /*
     * Handles server side exception, and determines the status.
     */
    protected Status handleServerException(Exception exception) {
        return handleException(exception);
    }

    /*
     * Handles client side exception, and determines the status.
     */
    protected Status handleClientException(Exception exception) {
        return handleException(exception);
    }

    private Status handleException(Exception exception) {
        if (exception == null) {
            return Status.PASS;
        }

        exception.printStackTrace(System.out);
        return Status.FAIL;
    }

    /*
     * Creates server.
     */
    protected AbstractServer createServer(U useCase, ExecutorService executor) throws Exception {
        AbstractServer server = createServerBuilder(useCase).build();
        executor.submit(new ServerTask(server));
        return server;
    }

    protected AbstractServer.Builder createServerBuilder(U useCase)
            throws Exception {
        return (JdkServer.Builder) ((JdkServer.Builder) new JdkServer.Builder()
                .setProtocols(useCase.getProtocols())
                .setCipherSuites(useCase.getCipherSuites())
                .setCertTuple(useCase.getCertTuple()))
                .setClientAuth(useCase.isClientAuth());
    }

    /*
     * Creates client.
     */
    protected AbstractClient createClient(U useCase) throws Exception {
        return createClientBuilder(useCase).build();
    }

    protected AbstractClient.Builder createClientBuilder(U useCase)
            throws Exception {
        return (JdkClient.Builder) new JdkClient.Builder()
                .setProtocols(useCase.getProtocols())
                .setCipherSuites(useCase.getCipherSuites())
                .setCertTuple(useCase.getCertTuple());
    }

    /*
     * Returns the maximum number of attempts to start a server.
     */
    protected int getServerMaxRetries() {
        return MAX_SERVER_RETRIES;
    }

    /*
     * Determines the negotiated application protocol.
     * Generally, using JDK client to get this value.
     */
    protected String getNegoAppProtocol(AbstractServer server,
            AbstractClient client) throws SSLTestException {
        return isJdkClient() ? client.getNegoAppProtocol()
                             : server.getNegoAppProtocol();
    }

    protected static class ServerTask implements Callable<Void> {

        private final AbstractServer server;

        protected ServerTask(AbstractServer server) {
            this.server = server;
        }

        @Override
        public Void call() throws IOException {
            server.accept();
            return null;
        }
    }

    protected static class ClientTask implements Callable<Exception> {

        private final AbstractClient client;

        private final String host;
        private final int port;

        protected ClientTask(AbstractClient client, String host, int port) {
            this.client = client;

            this.host = host;
            this.port = port;
        }

        protected ClientTask(AbstractClient client, int port) {
            this(client, "localhost", port);
        }

        @Override
        public Exception call() {
            try (AbstractClient c = client) {
                c.connect(host, port);
            } catch (Exception exception) {
                return exception;
            }

            return null;
        }
    }
}