lib/toolbox/JarTask.java

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

package toolbox;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOError;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.tools.FileObject;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import static toolbox.ToolBox.currDir;

/**
 * A task to configure and run the jar file utility.
 */
public class JarTask extends AbstractTask<JarTask> {
    private Path jar;
    private Manifest manifest;
    private String classpath;
    private String mainClass;
    private Path baseDir;
    private List<Path> paths;
    private Set<FileObject> fileObjects;

    /**
     * Creates a task to write jar files, using API mode.
     * @param toolBox the {@code ToolBox} to use
     */
    public JarTask(ToolBox toolBox) {
        super(toolBox, Task.Mode.API);
        paths = Collections.emptyList();
        fileObjects = new LinkedHashSet<>();
    }

    /**
     * Creates a JarTask for use with a given jar file.
     * @param toolBox the {@code ToolBox} to use
     * @param path the file
     */
    public JarTask(ToolBox toolBox, String path) {
        this(toolBox);
        jar = Paths.get(path);
    }

    /**
     * Creates a JarTask for use with a given jar file.
     * @param toolBox the {@code ToolBox} to use
     * @param path the file
     */
    public JarTask(ToolBox toolBox, Path path) {
        this(toolBox);
        jar = path;
    }

    /**
     * Sets a manifest for the jar file.
     * @param manifest the manifest
     * @return this task object
     */
    public JarTask manifest(Manifest manifest) {
        this.manifest = manifest;
        return this;
    }

    /**
     * Sets a manifest for the jar file.
     * @param manifest a string containing the contents of the manifest
     * @return this task object
     * @throws IOException if there is a problem creating the manifest
     */
    public JarTask manifest(String manifest) throws IOException {
        this.manifest = new Manifest(new ByteArrayInputStream(manifest.getBytes()));
        return this;
    }

    /**
     * Sets the classpath to be written to the {@code Class-Path}
     * entry in the manifest.
     * @param classpath the classpath
     * @return this task object
     */
    public JarTask classpath(String classpath) {
        this.classpath = classpath;
        return this;
    }

    /**
     * Sets the class to be written to the {@code Main-Class}
     * entry in the manifest..
     * @param mainClass the name of the main class
     * @return this task object
     */
    public JarTask mainClass(String mainClass) {
        this.mainClass = mainClass;
        return this;
    }

    /**
     * Sets the base directory for files to be written into the jar file.
     * @param baseDir the base directory
     * @return this task object
     */
    public JarTask baseDir(String baseDir) {
        this.baseDir = Paths.get(baseDir);
        return this;
    }

    /**
     * Sets the base directory for files to be written into the jar file.
     * @param baseDir the base directory
     * @return this task object
     */
    public JarTask baseDir(Path baseDir) {
        this.baseDir = baseDir;
        return this;
    }

    /**
     * Sets the files to be written into the jar file.
     * @param files the files
     * @return this task object
     */
    public JarTask files(String... files) {
        this.paths = Stream.of(files)
                .map(file -> Paths.get(file))
                .collect(Collectors.toList());
        return this;
    }

    /**
     * Adds a set of file objects to be written into the jar file, by copying them
     * from a Location in a JavaFileManager.
     * The file objects to be written are specified by a series of paths;
     * each path can be in one of the following forms:
     * <ul>
     * <li>The name of a class. For example, java.lang.Object.
     * In this case, the corresponding .class file will be written to the jar file.
     * <li>the name of a package followed by {@code .*}. For example, {@code java.lang.*}.
     * In this case, all the class files in the specified package will be written to
     * the jar file.
     * <li>the name of a package followed by {@code .**}. For example, {@code java.lang.**}.
     * In this case, all the class files in the specified package, and any subpackages
     * will be written to the jar file.
     * </ul>
     *
     * @param fm the file manager in which to find the file objects
     * @param l  the location in which to find the file objects
     * @param paths the paths specifying the file objects to be copied
     * @return this task object
     * @throws IOException if errors occur while determining the set of file objects
     */
    public JarTask files(JavaFileManager fm, JavaFileManager.Location l, String... paths)
            throws IOException {
        for (String p : paths) {
            if (p.endsWith(".**"))
                addPackage(fm, l, p.substring(0, p.length() - 3), true);
            else if (p.endsWith(".*"))
                addPackage(fm, l, p.substring(0, p.length() - 2), false);
            else
                addFile(fm, l, p);
        }
        return this;
    }

    private void addPackage(JavaFileManager fm, JavaFileManager.Location l, String pkg, boolean recurse)
            throws IOException {
        for (JavaFileObject fo : fm.list(l, pkg, EnumSet.allOf(JavaFileObject.Kind.class), recurse)) {
            fileObjects.add(fo);
        }
    }

    private void addFile(JavaFileManager fm, JavaFileManager.Location l, String path) throws IOException {
        JavaFileObject fo = fm.getJavaFileForInput(l, path, JavaFileObject.Kind.CLASS);
        fileObjects.add(fo);
    }

    /**
     * Provides limited jar command-like functionality.
     * The supported commands are:
     * <ul>
     * <li> jar cf jarfile -C dir files...
     * <li> jar cfm jarfile manifestfile -C dir files...
     * </ul>
     * Any values specified by other configuration methods will be ignored.
     * @param args arguments in the style of those for the jar command
     * @return a Result object containing the results of running the task
     */
    public Task.Result run(String... args) {
        if (args.length < 2)
            throw new IllegalArgumentException();

        ListIterator<String> iter = Arrays.asList(args).listIterator();
        String first = iter.next();
        switch (first) {
            case "cf":
                jar = Paths.get(iter.next());
                break;
            case "cfm":
                jar = Paths.get(iter.next());
                try (InputStream in = Files.newInputStream(Paths.get(iter.next()))) {
                    manifest = new Manifest(in);
                } catch (IOException e) {
                    throw new IOError(e);
                }
                break;
        }

        if (iter.hasNext()) {
            if (iter.next().equals("-C"))
                baseDir = Paths.get(iter.next());
            else
                iter.previous();
        }

        paths = new ArrayList<>();
        while (iter.hasNext())
            paths.add(Paths.get(iter.next()));

        return run();
    }

    /**
     * {@inheritDoc}
     * @return the name "jar"
     */
    @Override
    public String name() {
        return "jar";
    }

    /**
     * Creates a jar file with the arguments as currently configured.
     * @return a Result object indicating the outcome of the compilation
     * and the content of any output written to stdout, stderr, or the
     * main stream by the compiler.
     * @throws TaskError if the outcome of the task is not as expected.
     */
    @Override
    public Task.Result run() {
        Manifest m = (manifest == null) ? new Manifest() : manifest;
        Attributes mainAttrs = m.getMainAttributes();
        if (mainClass != null)
            mainAttrs.put(Attributes.Name.MAIN_CLASS, mainClass);
        if (classpath != null)
            mainAttrs.put(Attributes.Name.CLASS_PATH, classpath);

        AbstractTask.StreamOutput sysOut = new AbstractTask.StreamOutput(System.out, System::setOut);
        AbstractTask.StreamOutput sysErr = new AbstractTask.StreamOutput(System.err, System::setErr);

        Map<Task.OutputKind, String> outputMap = new HashMap<>();

        try (OutputStream os = Files.newOutputStream(jar);
                JarOutputStream jos = openJar(os, m)) {
            writeFiles(jos);
            writeFileObjects(jos);
        } catch (IOException e) {
            error("Exception while opening " + jar, e);
        } finally {
            outputMap.put(Task.OutputKind.STDOUT, sysOut.close());
            outputMap.put(Task.OutputKind.STDERR, sysErr.close());
        }
        return checkExit(new Task.Result(toolBox, this, (errors == 0) ? 0 : 1, outputMap));
    }

    private JarOutputStream openJar(OutputStream os, Manifest m) throws IOException {
        if (m == null || m.getMainAttributes().isEmpty() && m.getEntries().isEmpty()) {
            return new JarOutputStream(os);
        } else {
            if (m.getMainAttributes().get(Attributes.Name.MANIFEST_VERSION) == null)
                m.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
            return new JarOutputStream(os, m);
        }
    }

    private void writeFiles(JarOutputStream jos) throws IOException {
            Path base = (baseDir == null) ? currDir : baseDir;
            for (Path path : paths) {
                Files.walkFileTree(base.resolve(path), new SimpleFileVisitor<Path>() {
                    @Override
                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                        try {
                        String p = base.relativize(file)
                                .normalize()
                                .toString()
                                .replace(File.separatorChar, '/');
                        JarEntry e = new JarEntry(p);
                            jos.putNextEntry(e);
                        try {
                            jos.write(Files.readAllBytes(file));
                        } finally {
                            jos.closeEntry();
                        }
                            return FileVisitResult.CONTINUE;
                        } catch (IOException e) {
                        error("Exception while adding " + file + " to jar file", e);
                            return FileVisitResult.TERMINATE;
                        }
                    }
                });
            }
    }

    private void writeFileObjects(JarOutputStream jos) throws IOException {
        for (FileObject fo : fileObjects) {
            String p = guessPath(fo);
            JarEntry e = new JarEntry(p);
            jos.putNextEntry(e);
            try {
                byte[] buf = new byte[1024];
                try (BufferedInputStream in = new BufferedInputStream(fo.openInputStream())) {
                    int n;
                    while ((n = in.read(buf)) > 0)
                        jos.write(buf, 0, n);
                } catch (IOException ex) {
                    error("Exception while adding " + fo.getName() + " to jar file", ex);
                }
        } finally {
                jos.closeEntry();
        }
        }
    }

    /*
     * A jar: URL is of the form  jar:URL!/<entry>  where URL is a URL for the .jar file itself.
     * In Symbol files (i.e. ct.sym) the underlying entry is prefixed META-INF/sym/<base>.
     */
    private final Pattern jarEntry = Pattern.compile(".*!/(?:META-INF/sym/[^/]+/)?(.*)");

    /*
     * A jrt: URL is of the form  jrt:/modules/<module>/<package>/<file>
     */
    private final Pattern jrtEntry = Pattern.compile("/modules/([^/]+)/(.*)");

    /*
     * A file: URL is of the form  file:/path/to/{modules,patches}/<module>/<package>/<file>
     */
    private final Pattern fileEntry = Pattern.compile(".*/(?:modules|patches)/([^/]+)/(.*)");

    private String guessPath(FileObject fo) {
        URI u = fo.toUri();
        switch (u.getScheme()) {
            case "jar": {
                Matcher m = jarEntry.matcher(u.getSchemeSpecificPart());
                if (m.matches()) {
                    return m.group(1);
                }
                break;
            }
            case "jrt": {
                Matcher m = jrtEntry.matcher(u.getSchemeSpecificPart());
                if (m.matches()) {
                    return m.group(2);
                }
                break;
            }
            case "file": {
                Matcher m = fileEntry.matcher(u.getSchemeSpecificPart());
                if (m.matches()) {
                    return m.group(2);
                }
                break;
            }
        }
        throw new IllegalArgumentException(fo.getName() + "--" + fo.toUri());
    }

    private void error(String message, Throwable t) {
        toolBox.out.println("Error: " + message + ": " + t);
        errors++;
    }

    private int errors;
}