Quelle  JImageValidator.java

/*
 * Copyright (c) 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.
 */
package tests;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.sun.tools.classfile.ClassFile;
import com.sun.tools.classfile.ConstantPoolException;
import jdk.internal.jimage.BasicImageReader;
import jdk.internal.jimage.ImageLocation;

/**
 *
 * JDK Modular image validator
 */
public class JImageValidator {

    private static final String[] dirs = {"bin", "lib"};

    private final File rootDir;
    private final List<String> expectedLocations;
    private final String module;
    private long moduleExecutionTime;
    private long javaExecutionTime;
    private final List<String> unexpectedPaths;
    private final List<String> unexpectedFiles;
    private final String[] expectedFiles;

    public JImageValidator(String module, List<String> expectedLocations,
            File rootDir,
            List<String> unexpectedPaths,
            List<String> unexpectedFiles) throws Exception {
        this(module, expectedLocations, rootDir, unexpectedPaths, unexpectedFiles, null);
    }

    public JImageValidator(String module, List<String> expectedLocations,
            File rootDir,
            List<String> unexpectedPaths,
            List<String> unexpectedFiles,
            String[] expectedFiles) throws IOException {
        if (!rootDir.exists()) {
            throw new IOException("Image root dir not found " +
                    rootDir.getAbsolutePath());
        }
        this.expectedLocations = expectedLocations;
        this.rootDir = rootDir;
        this.module = module;
        this.unexpectedPaths = unexpectedPaths;
        this.unexpectedFiles = unexpectedFiles;
        this.expectedFiles = expectedFiles == null ? new String[0] : expectedFiles;
    }

    public void validate() throws IOException {
        for (String d : dirs) {
            File dir = new File(rootDir, d);
            if (!dir.isDirectory()) {
                throw new IOException("Invalid directory " + d);
            }
        }

        //check jimage file
        Path path = rootDir.toPath().resolve("lib").resolve("modules");
        if (!Files.isRegularFile(path)) {
            throw new IOException(path + " No jimage file generated");
        }

        // Check binary file
        File launcher = new File(rootDir, "bin" + File.separator + module);
        if (launcher.exists()) {
            ProcessBuilder builder = new ProcessBuilder("sh", launcher.getAbsolutePath());
            long t = System.currentTimeMillis();
            Process process = builder.inheritIO().start();
            int ret = waitFor(process);
            moduleExecutionTime += System.currentTimeMillis() - t;
            if (ret != 0) {
                throw new IOException("Image " + module + " execution failed, check logs.");
            }
        }

        for (String f : expectedFiles) {
            File dd = new File(rootDir, f);
            if (!dd.exists()) {
                throw new IOException("Expected File " + f + " not found");
            }
        }

        //Walk and check that unexpected files are not there
        try (java.util.stream.Stream<Path> stream = Files.walk(rootDir.toPath())) {
            stream.forEach((p) -> {
                for (String u : unexpectedFiles) {
                    if (p.toString().equals(u)) {
                        throw new RuntimeException("Seen unexpected path " + p);
                    }
                }
            });
        }

        File javaLauncher = new File(rootDir, "bin" + File.separator +
                (isWindows() ? "java.exe" : "java"));
        if (javaLauncher.exists()) {
            ProcessBuilder builder = new ProcessBuilder(javaLauncher.getAbsolutePath(),
                    "-version");
            long t = System.currentTimeMillis();
            Process process = builder.start();
            int ret = waitFor(process);
            javaExecutionTime += System.currentTimeMillis() - t;
            if (ret != 0) {
                throw new RuntimeException("java launcher execution failed, check logs.");
            }
        } else {
            throw new IOException("java launcher not found.");
        }

        // Check release file
        File release = new File(rootDir, "release");
        if (!release.exists()) {
            throw new IOException("Release file not generated");
        } else {
            Properties props = new Properties();
            try (FileInputStream fs = new FileInputStream(release)) {
                props.load(fs);
                String s = props.getProperty("MODULES");
                if (s == null) {
                    throw new IOException("No MODULES property in release");
                }
                if (!s.contains(module)) {
                    throw new IOException("Module not found in release file " + s);
                }
            }
        }

    }

    private int waitFor(Process process) {
        try {
            return process.waitFor();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    private static boolean isWindows() {
        return System.getProperty("os.name").startsWith("Windows");
    }

    public static void validate(Path jimage, List<String> expectedLocations,
            List<String> unexpectedPaths) throws IOException {
        BasicImageReader reader = BasicImageReader.open(jimage);
        // Validate expected locations
        List<String> seenLocations = new ArrayList<>();
        for (String loc : expectedLocations) {
            ImageLocation il = reader.findLocation(loc);
            if (il == null) {
                throw new IOException("Location " + loc + " not present in " + jimage);
            }
        }
        seenLocations.addAll(expectedLocations);

        for (String s : reader.getEntryNames()) {
            if (s.endsWith(".class") && !s.endsWith("module-info.class")) {
                ImageLocation il = reader.findLocation(s);
                try {
                    byte[] r = reader.getResource(il);
                    if(r == null) {
                        System.out.println("IL, compressed " +
                                il.getCompressedSize() + " uncompressed " +
                                il.getUncompressedSize());
                        throw new IOException("NULL RESOURCE " + s);
                    }
                    readClass(r);
                } catch (IOException ex) {
                    System.err.println(s + " ERROR " + ex);
                    throw ex;
                }
            }
            if (seenLocations.contains(s)) {
                seenLocations.remove(s);
            }
            for(String p : unexpectedPaths) {
                if (s.equals(p)) {
                    throw new IOException("Seen unexpected path " + s);
                }
            }
        }
        if (!seenLocations.isEmpty()) {
            throw new IOException("ImageReader did not return " + seenLocations);
        }
    }

    public long getJavaLauncherExecutionTime() {
        return javaExecutionTime;
    }

    public long getModuleLauncherExecutionTime() {
        return moduleExecutionTime;
    }

    public static void readClass(byte[] clazz) throws IOException {
        try (InputStream stream = new ByteArrayInputStream(clazz)) {
            ClassFile.read(stream);
        } catch (ConstantPoolException e) {
            throw new IOException(e);
        }
    }
}