test/jdk/sun/misc/JarIndex/metaInfFilenames/Basic.java

/*
 * Copyright (c) 2011, 2015, 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.
 */

/*
 * @test
 * @bug 6887710
 * @summary Verify the impact of sun.misc.JarIndex.metaInfFilenames on ServiceLoader
 * @modules jdk.jartool/sun.tools.jar
 *          jdk.httpserver
 *          jdk.compiler
 *          jdk.zipfs
 * @run main/othervm Basic
 */

import java.io.IOException;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Arrays;
import java.util.Iterator;
import java.util.ServiceLoader;
import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

/**
 * Verifies the impact of sun.misc.JarIndex.metaInfFilenames on ServiceLoader
 * and on finding resources via Class.getResource.
 *
 * 1) Compile the test sources:
 *   jarA:
 *     META-INF/services/my.happy.land
 *     com/message/spi/MessageService.java
 *     a/A.java
 *   jarB:
 *     META-INF/JAVA2.DS
 *     META-INF/services/no.name.service
 *     b/B.java
 *   jarC:
 *     META-INF/fonts.mf
 *     META-INF/fonts/Company-corporate.ttf
 *     META-INF/fonts/kidpr.ttf
 *     META-INF/services/com.message.spi.MessageService
 *     my/impl/StandardMessageService.java
 *
 * 2) Build three jar files a.jar, b.jar, c.jar
 *
 * 3) Create an index in a.jar (jar -i a.jar b.jar c.jar)
 *      with sun.misc.JarIndex.metaInfFilenames=true
 *
 * 4) Start a HTTP server serving out the three jars.
 *
 * The test then tries to locate services/resources within the jars using
 * URLClassLoader. Each request to the HTTP server is recorded to ensure
 * only the correct amount of requests are being made.
 *
 */

public class Basic {
    static final String slash = File.separator;
    static final String[] testSources =  {
         "jarA" + slash + "a" + slash + "A.java",
         "jarA" + slash + "com" + slash + "message" + slash + "spi" + slash + "MessageService.java",
         "jarB" + slash + "b" + slash + "B.java",
         "jarC" + slash + "my" + slash + "impl" + slash + "StandardMessageService.java"};

    static final String testSrc = System.getProperty("test.src");
    static final String testSrcDir = testSrc != null ? testSrc : ".";
    static final String testClasses = System.getProperty("test.classes");
    static final String testClassesDir = testClasses != null ? testClasses : ".";

    static JarHttpServer httpServer;

    public static void main(String[] args) throws Exception {

        // Set global url cache to false so that we can track every jar request.
        (new URL("http://localhost/")).openConnection().setDefaultUseCaches(false);

        buildTest();

        try {
            httpServer = new JarHttpServer(testClassesDir);
            httpServer.start();

            doTest(httpServer.getAddress());

        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            if (httpServer != null) { httpServer.stop(2); }
        }
    }

    static void buildTest() {
        /* compile the source that will be used to generate the jars */
        for (int i=0; i<testSources.length; i++)
            testSources[i] = testSrcDir + slash + testSources[i];

        compile("-d" , testClassesDir,
                "-sourcepath", testSrcDir,
                testSources[0], testSources[1], testSources[2], testSources[3]);

        /* build the 3 jar files */
        jar("-cf", testClassesDir + slash + "a.jar",
            "-C", testClassesDir, "a",
            "-C", testClassesDir, "com",
            "-C", testSrcDir + slash + "jarA", "META-INF");
        jar("-cf", testClassesDir + slash + "b.jar",
            "-C", testClassesDir, "b",
            "-C", testSrcDir + slash + "jarB", "META-INF");
        jar("-cf", testClassesDir + slash + "c.jar",
            "-C", testClassesDir, "my",
            "-C", testSrcDir + slash + "jarC", "META-INF");

        /* Create an index in a.jar for b.jar and c.jar */
        createIndex(testClassesDir);
    }

    /* run jar <args> */
    static void jar(String... args) {
        debug("Running: jar " + Arrays.toString(args));
        sun.tools.jar.Main jar = new sun.tools.jar.Main(System.out, System.err, "jar");
        if (!jar.run(args)) {
            throw new RuntimeException("jar failed: args=" + Arrays.toString(args));
        }
    }

    /* run javac <args> */
    static void compile(String... args) {
        debug("Running: javac " + Arrays.toString(args));
        if (com.sun.tools.javac.Main.compile(args) != 0) {
             throw new RuntimeException("javac failed: args=" + Arrays.toString(args));
        }
    }

    static String jar;
    static {
        jar = System.getProperty("java.home") + slash+  "bin" + slash + "jar";
    }

    /* create the index */
    static void createIndex(String workingDir) {
        // ProcessBuilder is used so that the current directory can be set
        // to the directory that directly contains the jars.
        debug("Running jar to create the index");
        ProcessBuilder pb = new ProcessBuilder(
           jar, "-J-Dsun.misc.JarIndex.metaInfFilenames=true", "-i", "a.jar", "b.jar", "c.jar");
        pb.directory(new File(workingDir));
        //pd.inheritIO();
        try {
            Process p = pb.start();
            if(p.waitFor() != 0)
                throw new RuntimeException("jar indexing failed");

            if(debug && p != null) {
                String line = null;
                BufferedReader reader =
                         new BufferedReader(new InputStreamReader(p.getInputStream()));
                while((line = reader.readLine()) != null)
                    debug(line);
                reader = new BufferedReader(new InputStreamReader(p.getErrorStream()));
                while((line = reader.readLine()) != null)
                    debug(line);
            }
        } catch(InterruptedException ie) { throw new RuntimeException(ie);
        } catch(IOException e) { throw new RuntimeException(e); }
    }

    static final boolean debug = true;

    static void debug(Object message) { if (debug) System.out.println(message); }

    /* service define in c.jar */
    static final String messageService = "com.message.spi.MessageService";

    /* a service that is not defined in any of the jars */
    static final String unknownService = "java.lang.Object";

    static void doTest(InetSocketAddress serverAddress) throws IOException {
        URL baseURL = new URL("http://localhost:" + serverAddress.getPort() + "/");

        int failed = 0;

        // Tests using java.util.SerivceLoader
        if (!javaUtilServiceLoaderTest(baseURL, messageService, true, false, true)) {
            System.out.println("Test: ServiceLoader looking for " + messageService + ", failed");
            failed++;
        }
        if (!javaUtilServiceLoaderTest(baseURL, unknownService, false, false, false)) {
            System.out.println("Test: ServiceLoader looking for " + unknownService + " failed");
            failed++;
        }

        // Tests using java.lang.Class (similar to the FontManager in javafx)
        if (!klassLoader(baseURL, "/META-INF/fonts.mf", true, false, true)) {
            System.out.println("Test: klassLoader looking for /META-INF/fonts.mf failed");
            failed++;
        }
        if (!klassLoader(baseURL, "/META-INF/unknown.mf", false, false, false)) {
            System.out.println("Test: klassLoader looking for /META-INF/unknown.mf failed");
            failed++;
        }

        if (failed > 0)
            throw new RuntimeException("Failed: " + failed + " tests");
    }

    static boolean javaUtilServiceLoaderTest(URL baseURL,
                                             String serviceClass,
                                             boolean expectToFind,
                                             boolean expectbDotJar,
                                             boolean expectcDotJar) throws IOException {
        debug("----------------------------------");
        debug("Running test with java.util.ServiceLoader looking for " + serviceClass);
        URLClassLoader loader = getLoader(baseURL);
        httpServer.reset();

        Class<?> messageServiceClass = null;
        try {
            messageServiceClass = loader.loadClass(serviceClass);
        } catch (ClassNotFoundException cnfe) {
            System.err.println(cnfe);
            throw new RuntimeException("Error in test: " + cnfe);
        }

        Iterator<?> iterator = (ServiceLoader.load(messageServiceClass, loader)).iterator();
        if (expectToFind && !iterator.hasNext()) {
            debug(messageServiceClass + " NOT found.");
            return false;
        }

        while (iterator.hasNext()) {
            debug("found " + iterator.next() + " " + messageService);
        }

        debug("HttpServer: " + httpServer);

        if (!expectbDotJar && httpServer.bDotJar > 0) {
            debug("Unexpeced request sent to the httpserver for b.jar");
            return false;
        }
        if (!expectcDotJar && httpServer.cDotJar > 0) {
            debug("Unexpeced request sent to the httpserver for c.jar");
            return false;
        }

        return true;
    }

    /* Tries to find a resource in a similar way to the font manager in javafx
     * com.sun.javafx.scene.text.FontManager */
    static boolean klassLoader(URL baseURL,
                               String resource,
                               boolean expectToFind,
                               boolean expectbDotJar,
                               boolean expectcDotJar) throws IOException {
        debug("----------------------------------");
        debug("Running test looking for " + resource);
        URLClassLoader loader = getLoader(baseURL);
        httpServer.reset();

        Class<?> ADotAKlass = null;
        try {
            ADotAKlass = loader.loadClass("a.A");
        } catch (ClassNotFoundException cnfe) {
            System.err.println(cnfe);
            throw new RuntimeException("Error in test: " + cnfe);
        }

        URL u = ADotAKlass.getResource(resource);
        if (expectToFind && u == null) {
            System.out.println("Expected to find " + resource + " but didn't");
            return false;
        }

        debug("HttpServer: " + httpServer);

        if (!expectbDotJar && httpServer.bDotJar > 0) {
            debug("Unexpeced request sent to the httpserver for b.jar");
            return false;
        }
        if (!expectcDotJar && httpServer.cDotJar > 0) {
            debug("Unexpeced request sent to the httpserver for c.jar");
            return false;
        }

        return true;
    }

    static URLClassLoader getLoader(URL baseURL) throws IOException {
        ClassLoader loader = Basic.class.getClassLoader();

        while (loader.getParent() != null)
            loader = loader.getParent();

        return new URLClassLoader( new URL[]{
            new URL(baseURL, "a.jar"),
            new URL(baseURL, "b.jar"),
            new URL(baseURL, "c.jar")}, loader );
    }

    /**
     * HTTP Server to server the jar files.
     */
    static class JarHttpServer implements HttpHandler {
        final String docsDir;
        final HttpServer httpServer;
        int aDotJar, bDotJar, cDotJar;

        JarHttpServer(String docsDir) throws IOException {
            this.docsDir = docsDir;

            httpServer = HttpServer.create(new InetSocketAddress(0), 0);
            httpServer.createContext("/", this);
        }

        void start() throws IOException {
            httpServer.start();
        }

        void stop(int delay) {
            httpServer.stop(delay);
        }

        InetSocketAddress getAddress() {
            return httpServer.getAddress();
        }

        void reset() {
            aDotJar = bDotJar = cDotJar = 0;
        }

        @Override
        public String toString() {
            return "aDotJar=" + aDotJar + ", bDotJar=" + bDotJar + ", cDotJar=" + cDotJar;
        }

        public void handle(HttpExchange t) throws IOException {
            InputStream is = t.getRequestBody();
            Headers map = t.getRequestHeaders();
            Headers rmap = t.getResponseHeaders();
            URI uri = t.getRequestURI();

            debug("Server: received request for " + uri);
            String path = uri.getPath();
            if (path.endsWith("a.jar"))
                aDotJar++;
            else if (path.endsWith("b.jar"))
                bDotJar++;
            else if (path.endsWith("c.jar"))
                cDotJar++;
            else
                System.out.println("Unexpected resource request" + path);

            while (is.read() != -1);
            is.close();

            File file = new File(docsDir, path);
            if (!file.exists())
                throw new RuntimeException("Error: request for " + file);
            long clen = file.length();
            t.sendResponseHeaders (200, clen);
            OutputStream os = t.getResponseBody();
            FileInputStream fis = new FileInputStream(file);
            try {
                byte[] buf = new byte [16 * 1024];
                int len;
                while ((len=fis.read(buf)) != -1) {
                    os.write (buf, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            fis.close();
            os.close();
        }
    }
}