| /* | |
| * Copyright (c) 2015, 2024, 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. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * 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 jdk.tools.jlink.internal; | |
| import static jdk.tools.jlink.internal.TaskHelper.JLINK_BUNDLE; | |
| import java.io.BufferedInputStream; | |
| import java.io.File; | |
| import java.io.IOException; | |
| import java.io.InputStream; | |
| import java.io.PrintWriter; | |
| import java.io.UncheckedIOException; | |
| import java.lang.module.Configuration; | |
| import java.lang.module.FindException; | |
| import java.lang.module.ModuleDescriptor; | |
| import java.lang.module.ModuleFinder; | |
| import java.lang.module.ModuleReference; | |
| import java.lang.module.ResolutionException; | |
| import java.lang.module.ResolvedModule; | |
| import java.net.URI; | |
| import java.nio.ByteOrder; | |
| 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.Comparator; | |
| import java.util.Date; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.List; | |
| import java.util.Locale; | |
| import java.util.Map; | |
| import java.util.Objects; | |
| import java.util.Optional; | |
| import java.util.Set; | |
| import java.util.stream.Collectors; | |
| import java.util.stream.Stream; | |
| import jdk.internal.module.ModuleBootstrap; | |
| import jdk.internal.module.ModulePath; | |
| import jdk.internal.module.ModuleReferenceImpl; | |
| import jdk.internal.module.ModuleResolution; | |
| import jdk.internal.opt.CommandLine; | |
| import jdk.tools.jlink.internal.ImagePluginStack.ImageProvider; | |
| import jdk.tools.jlink.internal.Jlink.JlinkConfiguration; | |
| import jdk.tools.jlink.internal.Jlink.PluginsConfiguration; | |
| import jdk.tools.jlink.internal.TaskHelper.BadArgs; | |
| import jdk.tools.jlink.internal.TaskHelper.Option; | |
| import jdk.tools.jlink.internal.TaskHelper.OptionsHelper; | |
| import jdk.tools.jlink.plugin.PluginException; | |
| /** | |
| * Implementation for the jlink tool. | |
| * | |
| * ## Should use jdk.joptsimple some day. | |
| */ | |
| public class JlinkTask { | |
| public static final boolean DEBUG = Boolean.getBoolean("jlink.debug"); | |
| // jlink API ignores by default. Remove when signing is implemented. | |
| static final boolean IGNORE_SIGNING_DEFAULT = true; | |
| private static final TaskHelper taskHelper | |
| = new TaskHelper(JLINK_BUNDLE); | |
| private static final Option<?>[] recognizedOptions = { | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.help = true; | |
| }, "--help", "-h", "-?"), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| // if used multiple times, the last one wins! | |
| // So, clear previous values, if any. | |
| task.options.modulePath.clear(); | |
| String[] dirs = arg.split(File.pathSeparator); | |
| Arrays.stream(dirs) | |
| .map(Paths::get) | |
| .forEach(task.options.modulePath::add); | |
| }, "--module-path", "-p"), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| // if used multiple times, the last one wins! | |
| // So, clear previous values, if any. | |
| task.options.limitMods.clear(); | |
| for (String mn : arg.split(",")) { | |
| if (mn.isEmpty()) { | |
| throw taskHelper.newBadArgs("err.mods.must.be.specified", | |
| "--limit-modules"); | |
| } | |
| task.options.limitMods.add(mn); | |
| } | |
| }, "--limit-modules"), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| for (String mn : arg.split(",")) { | |
| if (mn.isEmpty()) { | |
| throw taskHelper.newBadArgs("err.mods.must.be.specified", | |
| "--add-modules"); | |
| } | |
| task.options.addMods.add(mn); | |
| } | |
| }, "--add-modules"), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| Path path = Paths.get(arg); | |
| task.options.output = path; | |
| }, "--output"), | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.bindServices = true; | |
| }, "--bind-services"), | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.suggestProviders = true; | |
| }, "--suggest-providers", "", true), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| String[] values = arg.split("="); | |
| // check values | |
| if (values.length != 2 || values[0].isEmpty() || values[1].isEmpty()) { | |
| throw taskHelper.newBadArgs("err.launcher.value.format", arg); | |
| } else { | |
| String commandName = values[0]; | |
| String moduleAndMain = values[1]; | |
| int idx = moduleAndMain.indexOf("/"); | |
| if (idx != -1) { | |
| if (moduleAndMain.substring(0, idx).isEmpty()) { | |
| throw taskHelper.newBadArgs("err.launcher.module.name.empty", arg); | |
| } | |
| if (moduleAndMain.substring(idx + 1).isEmpty()) { | |
| throw taskHelper.newBadArgs("err.launcher.main.class.empty", arg); | |
| } | |
| } | |
| task.options.launchers.put(commandName, moduleAndMain); | |
| } | |
| }, "--launcher"), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| if ("little".equals(arg)) { | |
| task.options.endian = ByteOrder.LITTLE_ENDIAN; | |
| } else if ("big".equals(arg)) { | |
| task.options.endian = ByteOrder.BIG_ENDIAN; | |
| } else { | |
| throw taskHelper.newBadArgs("err.unknown.byte.order", arg); | |
| } | |
| }, "--endian"), | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.verbose = true; | |
| }, "--verbose", "-v"), | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.version = true; | |
| }, "--version"), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| Path path = Paths.get(arg); | |
| if (Files.exists(path)) { | |
| throw taskHelper.newBadArgs("err.dir.exists", path); | |
| } | |
| task.options.packagedModulesPath = path; | |
| }, true, "--keep-packaged-modules"), | |
| new Option<JlinkTask>(true, (task, opt, arg) -> { | |
| task.options.saveoptsfile = arg; | |
| }, "--save-opts"), | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.fullVersion = true; | |
| }, true, "--full-version"), | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.ignoreSigning = true; | |
| }, "--ignore-signing-information"), | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.ignoreModifiedRuntime = true; | |
| }, true, "--ignore-modified-runtime"), | |
| // option for generating a runtime that can then | |
| // be used for linking from the run-time image. | |
| new Option<JlinkTask>(false, (task, opt, arg) -> { | |
| task.options.generateLinkableRuntime = true; | |
| }, true, "--generate-linkable-runtime") | |
| }; | |
| private static final String PROGNAME = "jlink"; | |
| private final OptionsValues options = new OptionsValues(); | |
| private static final OptionsHelper<JlinkTask> optionsHelper | |
| = taskHelper.newOptionsHelper(JlinkTask.class, recognizedOptions); | |
| private PrintWriter log; | |
| void setLog(PrintWriter out, PrintWriter err) { | |
| log = out; | |
| taskHelper.setLog(log); | |
| } | |
| /** | |
| * Result codes. | |
| */ | |
| static final int | |
| EXIT_OK = 0, // Completed with no errors. | |
| EXIT_ERROR = 1, // Completed but reported errors. | |
| EXIT_CMDERR = 2, // Bad command-line arguments | |
| EXIT_SYSERR = 3, // System error or resource exhaustion. | |
| EXIT_ABNORMAL = 4;// terminated abnormally | |
| static class OptionsValues { | |
| boolean help; | |
| String saveoptsfile; | |
| boolean verbose; | |
| boolean version; | |
| boolean fullVersion; | |
| final List<Path> modulePath = new ArrayList<>(); | |
| final Set<String> limitMods = new HashSet<>(); | |
| final Set<String> addMods = new HashSet<>(); | |
| Path output; | |
| final Map<String, String> launchers = new HashMap<>(); | |
| Path packagedModulesPath; | |
| ByteOrder endian; | |
| boolean ignoreSigning = false; | |
| boolean bindServices = false; | |
| boolean suggestProviders = false; | |
| boolean ignoreModifiedRuntime = false; | |
| boolean generateLinkableRuntime = false; | |
| } | |
| public static final String OPTIONS_RESOURCE = "jdk/tools/jlink/internal/options"; | |
| int run(String[] args) { | |
| if (log == null) { | |
| setLog(new PrintWriter(System.out, true), | |
| new PrintWriter(System.err, true)); | |
| } | |
| Path outputPath = null; | |
| try { | |
| Module m = JlinkTask.class.getModule(); | |
| try (InputStream savedOptions = m.getResourceAsStream(OPTIONS_RESOURCE)) { | |
| if (savedOptions != null) { | |
| List<String> prependArgs = new ArrayList<>(); | |
| CommandLine.loadCmdFile(savedOptions, prependArgs); | |
| if (!prependArgs.isEmpty()) { | |
| prependArgs.addAll(Arrays.asList(args)); | |
| args = prependArgs.toArray(new String[prependArgs.size()]); | |
| } | |
| } | |
| } | |
| List<String> remaining = optionsHelper.handleOptions(this, args); | |
| if (remaining.size() > 0 && !options.suggestProviders) { | |
| throw taskHelper.newBadArgs("err.orphan.arguments", | |
| remaining.stream().collect(Collectors.joining(" "))) | |
| .showUsage(true); | |
| } | |
| if (options.help) { | |
| optionsHelper.showHelp(PROGNAME, LinkableRuntimeImage.isLinkableRuntime()); | |
| return EXIT_OK; | |
| } | |
| if (optionsHelper.shouldListPlugins()) { | |
| optionsHelper.listPlugins(); | |
| return EXIT_OK; | |
| } | |
| if (options.version || options.fullVersion) { | |
| taskHelper.showVersion(options.fullVersion); | |
| return EXIT_OK; | |
| } | |
| JlinkConfiguration config = initJlinkConfig(); | |
| outputPath = config.getOutput(); | |
| if (options.suggestProviders) { | |
| suggestProviders(config, remaining); | |
| } else { | |
| createImage(config); | |
| if (options.saveoptsfile != null) { | |
| Files.write(Paths.get(options.saveoptsfile), getSaveOpts().getBytes()); | |
| } | |
| } | |
| return EXIT_OK; | |
| } catch (FindException e) { | |
| log.println(taskHelper.getMessage("error.prefix") + " " + e.getMessage()); | |
| e.printStackTrace(log); | |
| return EXIT_ERROR; | |
| } catch (PluginException | UncheckedIOException | IOException e) { | |
| log.println(taskHelper.getMessage("error.prefix") + " " + e.getMessage()); | |
| if (DEBUG) { | |
| e.printStackTrace(log); | |
| } | |
| cleanupOutput(outputPath); | |
| return EXIT_ERROR; | |
| } catch (IllegalArgumentException | ResolutionException e) { | |
| log.println(taskHelper.getMessage("error.prefix") + " " + e.getMessage()); | |
| if (DEBUG) { | |
| e.printStackTrace(log); | |
| } | |
| return EXIT_ERROR; | |
| } catch (BadArgs e) { | |
| taskHelper.reportError(e.key, e.args); | |
| if (e.showUsage) { | |
| log.println(taskHelper.getMessage("main.usage.summary", PROGNAME)); | |
| } | |
| if (DEBUG) { | |
| e.printStackTrace(log); | |
| } | |
| return EXIT_CMDERR; | |
| } catch (Throwable x) { | |
| log.println(taskHelper.getMessage("error.prefix") + " " + x.getMessage()); | |
| x.printStackTrace(log); | |
| cleanupOutput(outputPath); | |
| return EXIT_ABNORMAL; | |
| } finally { | |
| log.flush(); | |
| } | |
| } | |
| private void cleanupOutput(Path dir) { | |
| try { | |
| if (dir != null && Files.isDirectory(dir)) { | |
| deleteDirectory(dir); | |
| } | |
| } catch (IOException io) { | |
| log.println(taskHelper.getMessage("error.prefix") + " " + io.getMessage()); | |
| if (DEBUG) { | |
| io.printStackTrace(log); | |
| } | |
| } | |
| } | |
| /* | |
| * Jlink API entry point. | |
| */ | |
| public static void createImage(JlinkConfiguration config, | |
| PluginsConfiguration plugins) | |
| throws Exception { | |
| Objects.requireNonNull(config); | |
| Objects.requireNonNull(config.getOutput()); | |
| plugins = plugins == null ? new PluginsConfiguration() : plugins; | |
| // First create the image provider | |
| ImageProvider imageProvider = | |
| createImageProvider(config, | |
| null, | |
| IGNORE_SIGNING_DEFAULT, | |
| false, | |
| null, | |
| false, | |
| new OptionsValues(), | |
| null); | |
| // Then create the Plugin Stack | |
| ImagePluginStack stack = ImagePluginConfiguration.parseConfiguration(plugins); | |
| //Ask the stack to proceed; | |
| stack.operate(imageProvider); | |
| } | |
| // the token for "all modules on the module path" | |
| private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH"; | |
| private JlinkConfiguration initJlinkConfig() throws BadArgs { | |
| // Empty module path not allowed with ALL-MODULE-PATH in --add-modules | |
| if (options.addMods.contains(ALL_MODULE_PATH) && options.modulePath.isEmpty()) { | |
| throw taskHelper.newBadArgs("err.no.module.path"); | |
| } | |
| ModuleFinder appModuleFinder = newModuleFinder(options.modulePath); | |
| ModuleFinder finder = appModuleFinder; | |
| boolean isLinkFromRuntime = false; | |
| if (!appModuleFinder.find("java.base").isPresent()) { | |
| // If the application module finder doesn't contain the | |
| // java.base module we have one of two cases: | |
| // 1. A custom module is being linked into a runtime, but the JDK | |
| // modules have not been provided on the module path. | |
| // 2. We have a run-time image based link. | |
| // | |
| // Distinguish case 2 by adding the default 'jmods' folder and try | |
| // the look-up again. For case 1 this will now find java.base, but | |
| // not for case 2, since the jmods folder is not there or doesn't | |
| // include the java.base module. | |
| Path defModPath = getDefaultModulePath(); | |
| if (defModPath != null) { | |
| List<Path> combinedPaths = new ArrayList<>(options.modulePath); | |
| combinedPaths.add(defModPath); | |
| finder = newModuleFinder(combinedPaths); | |
| } | |
| // We've just added the default module path ('jmods'). If we still | |
| // don't find java.base, we must resolve JDK modules from the | |
| // current run-time image. | |
| if (!finder.find("java.base").isPresent()) { | |
| // If we don't have a linkable run-time image this is an error | |
| if (!LinkableRuntimeImage.isLinkableRuntime()) { | |
| throw taskHelper.newBadArgs("err.runtime.link.not.linkable.runtime"); | |
| } | |
| isLinkFromRuntime = true; | |
| // JDK modules come from the system module path | |
| finder = ModuleFinder.compose(ModuleFinder.ofSystem(), appModuleFinder); | |
| } | |
| } | |
| // Sanity check version if we use JMODs | |
| if (!isLinkFromRuntime) { | |
| checkJavaBaseVersion(finder); | |
| } | |
| // Determine the roots set | |
| Set<String> roots = new HashSet<>(); | |
| for (String mod : options.addMods) { | |
| if (mod.equals(ALL_MODULE_PATH)) { | |
| // Using --limit-modules with ALL-MODULE-PATH is an error | |
| if (!options.limitMods.isEmpty()) { | |
| throw taskHelper.newBadArgs("err.limit.modules"); | |
| } | |
| // all observable modules in the app module path are roots | |
| Set<String> initialRoots = appModuleFinder.findAll() | |
| .stream() | |
| .map(ModuleReference::descriptor) | |
| .map(ModuleDescriptor::name) | |
| .collect(Collectors.toSet()); | |
| // Error if no module is found on the app module path | |
| if (initialRoots.isEmpty()) { | |
| String modPath = options.modulePath.stream() | |
| .map(a -> a.toString()) | |
| .collect(Collectors.joining(", ")); | |
| throw taskHelper.newBadArgs("err.empty.module.path", modPath); | |
| } | |
| // Use a module finder with limited observability, as determined | |
| // by initialRoots, to find the observable modules from the | |
| // application module path (--module-path option) only. We must | |
| // not include JDK modules from the default module path or the | |
| // run-time image. | |
| ModuleFinder mf = limitFinder(finder, initialRoots, Set.of()); | |
| mf.findAll() | |
| .stream() | |
| .map(ModuleReference::descriptor) | |
| .map(ModuleDescriptor::name) | |
| .forEach(mn -> roots.add(mn)); | |
| } else { | |
| roots.add(mod); | |
| } | |
| } | |
| finder = limitFinder(finder, options.limitMods, roots); | |
| // --keep-packaged-modules doesn't make sense as we are not linking | |
| // from packaged modules to begin with. | |
| if (isLinkFromRuntime && options.packagedModulesPath != null) { | |
| throw taskHelper.newBadArgs("err.runtime.link.packaged.mods"); | |
| } | |
| return new JlinkConfiguration(options.output, | |
| roots, | |
| finder, | |
| isLinkFromRuntime, | |
| options.ignoreModifiedRuntime, | |
| options.generateLinkableRuntime); | |
| } | |
| /* | |
| * Creates a ModuleFinder for the given module paths. | |
| */ | |
| public static ModuleFinder newModuleFinder(List<Path> paths) { | |
| Runtime.Version version = Runtime.version(); | |
| Path[] entries = paths.toArray(new Path[0]); | |
| return ModulePath.of(version, true, entries); | |
| } | |
| private void createImage(JlinkConfiguration config) throws Exception { | |
| if (options.output == null) { | |
| throw taskHelper.newBadArgs("err.output.must.be.specified").showUsage(true); | |
| } | |
| if (options.addMods.isEmpty()) { | |
| throw taskHelper.newBadArgs("err.mods.must.be.specified", "--add-modules") | |
| .showUsage(true); | |
| } | |
| // First create the image provider | |
| ImageHelper imageProvider = createImageProvider(config, | |
| options.packagedModulesPath, | |
| options.ignoreSigning, | |
| options.bindServices, | |
| options.endian, | |
| options.verbose, | |
| options, | |
| log); | |
| // Then create the Plugin Stack | |
| ImagePluginStack stack = ImagePluginConfiguration.parseConfiguration( | |
| taskHelper.getPluginsConfig(options.output, options.launchers, | |
| imageProvider.targetPlatform)); | |
| //Ask the stack to proceed | |
| stack.operate(imageProvider); | |
| } | |
| /** | |
| * @return the system module path or null | |
| */ | |
| public static Path getDefaultModulePath() { | |
| Path jmods = Paths.get(System.getProperty("java.home"), "jmods"); | |
| return Files.isDirectory(jmods)? jmods : null; | |
| } | |
| /* | |
| * Returns a module finder of the given module finder that limits the | |
| * observable modules to those in the transitive closure of the modules | |
| * specified in {@code limitMods} plus other modules specified in the | |
| * {@code roots} set. | |
| */ | |
| public static ModuleFinder limitFinder(ModuleFinder finder, | |
| Set<String> limitMods, | |
| Set<String> roots) { | |
| // if limitMods is specified then limit the universe | |
| if (limitMods != null && !limitMods.isEmpty()) { | |
| Objects.requireNonNull(roots); | |
| // resolve all root modules | |
| Configuration cf = Configuration.empty() | |
| .resolve(finder, | |
| ModuleFinder.of(), | |
| limitMods); | |
| // module name -> reference | |
| Map<String, ModuleReference> map = new HashMap<>(); | |
| cf.modules().forEach(m -> { | |
| ModuleReference mref = m.reference(); | |
| map.put(mref.descriptor().name(), mref); | |
| }); | |
| // add the other modules | |
| roots.stream() | |
| .map(finder::find) | |
| .flatMap(Optional::stream) | |
| .forEach(mref -> map.putIfAbsent(mref.descriptor().name(), mref)); | |
| // set of modules that are observable | |
| Set<ModuleReference> mrefs = new HashSet<>(map.values()); | |
| return new ModuleFinder() { | |
| @Override | |
| public Optional<ModuleReference> find(String name) { | |
| return Optional.ofNullable(map.get(name)); | |
| } | |
| @Override | |
| public Set<ModuleReference> findAll() { | |
| return mrefs; | |
| } | |
| }; | |
| } | |
| return finder; | |
| } | |
| /* | |
| * Checks the version of the module descriptor of java.base for compatibility | |
| * with the current runtime version. | |
| * | |
| * @throws IllegalArgumentException the descriptor of java.base has no | |
| * version or the java.base version is not the same as the current runtime's | |
| * version. | |
| */ | |
| private static void checkJavaBaseVersion(ModuleFinder finder) { | |
| assert finder.find("java.base").isPresent(); | |
| // use the version of java.base module, if present, as | |
| // the release version for multi-release JAR files | |
| ModuleDescriptor.Version v = finder.find("java.base").get() | |
| .descriptor().version().orElseThrow(() -> | |
| new IllegalArgumentException("No version in java.base descriptor") | |
| ); | |
| Runtime.Version version = Runtime.Version.parse(v.toString()); | |
| if (Runtime.version().feature() != version.feature() || | |
| Runtime.version().interim() != version.interim()) { | |
| // jlink version and java.base version do not match. | |
| // We do not (yet) support this mode. | |
| throw new IllegalArgumentException(taskHelper.getMessage("err.jlink.version.mismatch", | |
| Runtime.version().feature(), Runtime.version().interim(), | |
| version.feature(), version.interim())); | |
| } | |
| } | |
| private static void deleteDirectory(Path dir) throws IOException { | |
| Files.walkFileTree(dir, new SimpleFileVisitor<Path>() { | |
| @Override | |
| public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) | |
| throws IOException { | |
| Files.delete(file); | |
| return FileVisitResult.CONTINUE; | |
| } | |
| @Override | |
| public FileVisitResult postVisitDirectory(Path dir, IOException e) | |
| throws IOException { | |
| if (e == null) { | |
| Files.delete(dir); | |
| return FileVisitResult.CONTINUE; | |
| } else { | |
| // directory iteration failed. | |
| throw e; | |
| } | |
| } | |
| }); | |
| } | |
| private static Path toPathLocation(ResolvedModule m) { | |
| Optional<URI> ouri = m.reference().location(); | |
| if (ouri.isEmpty()) { | |
| throw new InternalError(m + " does not have a location"); | |
| } | |
| URI uri = ouri.get(); | |
| return Paths.get(uri); | |
| } | |
| private static ImageHelper createImageProvider(JlinkConfiguration config, | |
| Path retainModulesPath, | |
| boolean ignoreSigning, | |
| boolean bindService, | |
| ByteOrder endian, | |
| boolean verbose, | |
| OptionsValues opts, | |
| PrintWriter log) | |
| throws IOException | |
| { | |
| Configuration cf = bindService ? config.resolveAndBind() | |
| : config.resolve(); | |
| cf.modules().stream() | |
| .map(ResolvedModule::reference) | |
| .filter(mref -> mref.descriptor().isAutomatic()) | |
| .findAny() | |
| .ifPresent(mref -> { | |
| String loc = mref.location().map(URI::toString).orElse("<unknown>"); | |
| throw new IllegalArgumentException( | |
| taskHelper.getMessage("err.automatic.module", mref.descriptor().name(), loc)); | |
| }); | |
| // Perform some sanity checks for linking from the run-time image | |
| if (config.linkFromRuntimeImage()) { | |
| // Do not permit linking from run-time image and also including jdk.jlink module | |
| if (cf.findModule(JlinkTask.class.getModule().getName()).isPresent()) { | |
| String msg = taskHelper.getMessage("err.runtime.link.jdk.jlink.prohibited"); | |
| throw new IllegalArgumentException(msg); | |
| } | |
| // Do not permit linking from run-time image when the current image | |
| // is being patched. | |
| if (ModuleBootstrap.patcher().hasPatches()) { | |
| String msg = taskHelper.getMessage("err.runtime.link.patched.module"); | |
| throw new IllegalArgumentException(msg); | |
| } | |
| // Print info message indicating linking from the run-time image | |
| if (verbose && log != null) { | |
| log.println(taskHelper.getMessage("runtime.link.info")); | |
| } | |
| } | |
| if (verbose && log != null) { | |
| // print modules to be linked in | |
| cf.modules().stream() | |
| .sorted(Comparator.comparing(ResolvedModule::name)) | |
| .forEach(rm -> log.format("%s %s%s%n", | |
| rm.name(), | |
| rm.reference().location().get(), | |
| // We have a link from run-time image when scheme is 'jrt' | |
| "jrt".equals(rm.reference().location().get().getScheme()) | |
| ? " " + taskHelper.getMessage("runtime.link.jprt.path.extra") | |
| : "")); | |
| // print provider info | |
| Set<ModuleReference> references = cf.modules().stream() | |
| .map(ResolvedModule::reference).collect(Collectors.toSet()); | |
| String msg = String.format("%n%s:", taskHelper.getMessage("providers.header")); | |
| printProviders(log, msg, references); | |
| } | |
| // emit a warning for any incubating modules in the configuration | |
| if (log != null) { | |
| String im = cf.modules() | |
| .stream() | |
| .map(ResolvedModule::reference) | |
| .filter(ModuleResolution::hasIncubatingWarning) | |
| .map(ModuleReference::descriptor) | |
| .map(ModuleDescriptor::name) | |
| .collect(Collectors.joining(", ")); | |
| if (!"".equals(im)) { | |
| log.println("WARNING: Using incubator modules: " + im); | |
| } | |
| } | |
| Map<String, Path> mods = cf.modules().stream() | |
| .collect(Collectors.toMap(ResolvedModule::name, JlinkTask::toPathLocation)); | |
| // determine the target platform of the image being created | |
| Platform targetPlatform = targetPlatform(cf, mods, config.linkFromRuntimeImage()); | |
| // if the user specified any --endian, then it must match the target platform's native | |
| // endianness | |
| if (endian != null && endian != targetPlatform.arch().byteOrder()) { | |
| throw new IOException( | |
| taskHelper.getMessage("err.target.endianness.mismatch", endian, targetPlatform)); | |
| } | |
| if (verbose && log != null) { | |
| Platform runtime = Platform.runtime(); | |
| if (runtime.os() != targetPlatform.os() || runtime.arch() != targetPlatform.arch()) { | |
| log.format("Cross-platform image generation, using %s for target platform %s%n", | |
| targetPlatform.arch().byteOrder(), targetPlatform); | |
| } | |
| } | |
| // use the version of java.base module, if present, as | |
| // the release version for multi-release JAR files | |
| var version = cf.findModule("java.base") | |
| .map(ResolvedModule::reference) | |
| .map(ModuleReference::descriptor) | |
| .flatMap(ModuleDescriptor::version) | |
| .map(ModuleDescriptor.Version::toString) | |
| .map(Runtime.Version::parse) | |
| .orElse(Runtime.version()); | |
| Set<Archive> archives = mods.entrySet().stream() | |
| .map(e -> newArchive(e.getKey(), | |
| e.getValue(), | |
| version, | |
| ignoreSigning, | |
| config, | |
| log)) | |
| .collect(Collectors.toSet()); | |
| return new ImageHelper(archives, | |
| targetPlatform, | |
| retainModulesPath, | |
| config.isGenerateRuntimeImage()); | |
| } | |
| private static Archive newArchive(String module, | |
| Path path, | |
| Runtime.Version version, | |
| boolean ignoreSigning, | |
| JlinkConfiguration config, | |
| PrintWriter log) { | |
| if (path.toString().endsWith(".jmod")) { | |
| return new JmodArchive(module, path); | |
| } else if (path.toString().endsWith(".jar")) { | |
| ModularJarArchive modularJarArchive = new ModularJarArchive(module, path, version); | |
| try (Stream<Archive.Entry> entries = modularJarArchive.entries()) { | |
| boolean hasSignatures = entries.anyMatch((entry) -> { | |
| String name = entry.name().toUpperCase(Locale.ROOT); | |
| return name.startsWith("META-INF/") && name.indexOf('/', 9) == -1 && ( | |
| name.endsWith(".SF") || | |
| name.endsWith(".DSA") || | |
| name.endsWith(".RSA") || | |
| name.endsWith(".EC") || | |
| name.startsWith("META-INF/SIG-") | |
| ); | |
| }); | |
| if (hasSignatures) { | |
| if (ignoreSigning) { | |
| System.err.println(taskHelper.getMessage("warn.signing", path)); | |
| } else { | |
| throw new IllegalArgumentException(taskHelper.getMessage("err.signing", path)); | |
| } | |
| } | |
| } | |
| return modularJarArchive; | |
| } else if (Files.isDirectory(path) && !"jrt".equals(path.toUri().getScheme())) { | |
| // The jrt URI path scheme conditional is there since we'd otherwise | |
| // enter this branch for linking from the run-time image where the | |
| // path is a jrt path. Note that the specific module would be a | |
| // directory. I.e. Files.isDirectory() would be true. | |
| Path modInfoPath = path.resolve("module-info.class"); | |
| if (Files.isRegularFile(modInfoPath)) { | |
| return new DirArchive(path, findModuleName(modInfoPath)); | |
| } else { | |
| throw new IllegalArgumentException( | |
| taskHelper.getMessage("err.not.a.module.directory", path)); | |
| } | |
| } else if (config.linkFromRuntimeImage()) { | |
| return LinkableRuntimeImage.newArchive(module, path, config.ignoreModifiedRuntime(), taskHelper); | |
| } else { | |
| throw new IllegalArgumentException( | |
| taskHelper.getMessage("err.not.modular.format", module, path)); | |
| } | |
| } | |
| private static String findModuleName(Path modInfoPath) { | |
| try (BufferedInputStream bis = new BufferedInputStream( | |
| Files.newInputStream(modInfoPath))) { | |
| return ModuleDescriptor.read(bis).name(); | |
| } catch (IOException exp) { | |
| throw new IllegalArgumentException(taskHelper.getMessage( | |
| "err.cannot.read.module.info", modInfoPath), exp); | |
| } | |
| } | |
| private static Platform targetPlatform(Configuration cf, | |
| Map<String, Path> modsPaths, | |
| boolean runtimeImageLink) throws IOException { | |
| Path javaBasePath = modsPaths.get("java.base"); | |
| assert javaBasePath != null : "java.base module path is missing"; | |
| if (runtimeImageLink || isJavaBaseFromDefaultModulePath(javaBasePath)) { | |
| // this implies that the java.base module used for the target image | |
| // will correspond to the current platform. So this isn't an attempt to | |
| // build a cross-platform image. We use the current platform's endianness | |
| // in this case | |
| return Platform.runtime(); | |
| } else { | |
| // this is an attempt to build a cross-platform image. We now attempt to | |
| // find the target platform's arch and thus its endianness from the java.base | |
| // module's ModuleTarget attribute | |
| String targetPlatformVal = readJavaBaseTargetPlatform(cf); | |
| try { | |
| return Platform.parsePlatform(targetPlatformVal); | |
| } catch (IllegalArgumentException iae) { | |
| throw new IOException( | |
| taskHelper.getMessage("err.unknown.target.platform", targetPlatformVal)); | |
| } | |
| } | |
| } | |
| // returns true if the default module-path is the parent of the passed javaBasePath | |
| private static boolean isJavaBaseFromDefaultModulePath(Path javaBasePath) throws IOException { | |
| Path defaultModulePath = getDefaultModulePath(); | |
| if (defaultModulePath == null) { | |
| return false; | |
| } | |
| // resolve, against the default module-path dir, the java.base module file used | |
| // for image creation | |
| Path javaBaseInDefaultPath = defaultModulePath.resolve(javaBasePath.getFileName()); | |
| if (Files.notExists(javaBaseInDefaultPath)) { | |
| // the java.base module used for image creation doesn't exist in the default | |
| // module path | |
| return false; | |
| } | |
| return Files.isSameFile(javaBasePath, javaBaseInDefaultPath); | |
| } | |
| // returns the targetPlatform value from the ModuleTarget attribute of the java.base module. | |
| // throws IOException if the targetPlatform cannot be determined. | |
| private static String readJavaBaseTargetPlatform(Configuration cf) throws IOException { | |
| Optional<ResolvedModule> javaBase = cf.findModule("java.base"); | |
| assert javaBase.isPresent() : "java.base module is missing"; | |
| ModuleReference ref = javaBase.get().reference(); | |
| if (ref instanceof ModuleReferenceImpl modRefImpl | |
| && modRefImpl.moduleTarget() != null) { | |
| return modRefImpl.moduleTarget().targetPlatform(); | |
| } | |
| // could not determine target platform | |
| throw new IOException( | |
| taskHelper.getMessage("err.cannot.determine.target.platform", | |
| ref.location().map(URI::toString) | |
| .orElse("java.base module"))); | |
| } | |
| /* | |
| * Returns a map of each service type to the modules that use it | |
| * It will include services that are provided by a module but may not used | |
| * by any of the observable modules. | |
| */ | |
| private static Map<String, Set<String>> uses(Set<ModuleReference> modules) { | |
| // collects the services used by the modules and print uses | |
| Map<String, Set<String>> services = new HashMap<>(); | |
| modules.stream() | |
| .map(ModuleReference::descriptor) | |
| .forEach(md -> { | |
| // include services that may not be used by any observable modules | |
| md.provides().forEach(p -> | |
| services.computeIfAbsent(p.service(), _k -> new HashSet<>())); | |
| md.uses().forEach(s -> services.computeIfAbsent(s, _k -> new HashSet<>()) | |
| .add(md.name())); | |
| }); | |
| return services; | |
| } | |
| private static void printProviders(PrintWriter log, | |
| String header, | |
| Set<ModuleReference> modules) { | |
| printProviders(log, header, modules, uses(modules)); | |
| } | |
| /* | |
| * Prints the providers that are used by the specified services. | |
| * | |
| * The specified services maps a service type name to the modules | |
| * using the service type which may be empty if no observable module uses | |
| * that service. | |
| */ | |
| private static void printProviders(PrintWriter log, | |
| String header, | |
| Set<ModuleReference> modules, | |
| Map<String, Set<String>> serviceToUses) { | |
| if (modules.isEmpty()) { | |
| return; | |
| } | |
| // Build a map of a service type to the provider modules | |
| Map<String, Set<ModuleDescriptor>> providers = new HashMap<>(); | |
| modules.stream() | |
| .map(ModuleReference::descriptor) | |
| .forEach(md -> { | |
| md.provides().stream() | |
| .filter(p -> serviceToUses.containsKey(p.service())) | |
| .forEach(p -> providers.computeIfAbsent(p.service(), _k -> new HashSet<>()) | |
| .add(md)); | |
| }); | |
| if (!providers.isEmpty()) { | |
| log.println(header); | |
| } | |
| // print the providers of the service types used by the specified modules | |
| // sorted by the service type name and then provider's module name | |
| providers.entrySet().stream() | |
| .sorted(Map.Entry.comparingByKey()) | |
| .forEach(e -> { | |
| String service = e.getKey(); | |
| e.getValue().stream() | |
| .sorted(Comparator.comparing(ModuleDescriptor::name)) | |
| .forEach(md -> | |
| md.provides().stream() | |
| .filter(p -> p.service().equals(service)) | |
| .forEach(p -> { | |
| String usedBy; | |
| if (serviceToUses.get(p.service()).isEmpty()) { | |
| usedBy = "not used by any observable module"; | |
| } else { | |
| usedBy = serviceToUses.get(p.service()).stream() | |
| .sorted() | |
| .collect(Collectors.joining(",", "used by ", "")); | |
| } | |
| log.format(" %s provides %s %s%n", | |
| md.name(), p.service(), usedBy); | |
| }) | |
| ); | |
| }); | |
| } | |
| private void suggestProviders(JlinkConfiguration config, List<String> args) | |
| throws BadArgs | |
| { | |
| if (args.size() > 1) { | |
| List<String> arguments = args.get(0).startsWith("-") | |
| ? args | |
| : args.subList(1, args.size()); | |
| throw taskHelper.newBadArgs("err.invalid.arg.for.option", | |
| "--suggest-providers", | |
| arguments.stream().collect(Collectors.joining(" "))); | |
| } | |
| if (options.bindServices) { | |
| log.println(taskHelper.getMessage("no.suggested.providers")); | |
| return; | |
| } | |
| ModuleFinder finder = config.finder(); | |
| if (args.isEmpty()) { | |
| // print providers used by the observable modules without service binding | |
| Set<ModuleReference> mrefs = finder.findAll(); | |
| // print uses of the modules that would be linked into the image | |
| mrefs.stream() | |
| .sorted(Comparator.comparing(mref -> mref.descriptor().name())) | |
| .forEach(mref -> { | |
| ModuleDescriptor md = mref.descriptor(); | |
| log.format("%s %s%n", md.name(), | |
| mref.location().get()); | |
| md.uses().stream().sorted() | |
| .forEach(s -> log.format(" uses %s%n", s)); | |
| }); | |
| String msg = String.format("%n%s:", taskHelper.getMessage("suggested.providers.header")); | |
| printProviders(log, msg, mrefs, uses(mrefs)); | |
| } else { | |
| // comma-separated service types, if specified | |
| Set<String> names = Stream.of(args.get(0).split(",")) | |
| .collect(Collectors.toSet()); | |
| // find the modules that provide the specified service | |
| Set<ModuleReference> mrefs = finder.findAll().stream() | |
| .filter(mref -> mref.descriptor().provides().stream() | |
| .map(ModuleDescriptor.Provides::service) | |
| .anyMatch(names::contains)) | |
| .collect(Collectors.toSet()); | |
| // find the modules that uses the specified services | |
| Map<String, Set<String>> uses = new HashMap<>(); | |
| names.forEach(s -> uses.computeIfAbsent(s, _k -> new HashSet<>())); | |
| finder.findAll().stream() | |
| .map(ModuleReference::descriptor) | |
| .forEach(md -> md.uses().stream() | |
| .filter(names::contains) | |
| .forEach(s -> uses.get(s).add(md.name()))); | |
| // check if any name given on the command line are not provided by any module | |
| mrefs.stream() | |
| .flatMap(mref -> mref.descriptor().provides().stream() | |
| .map(ModuleDescriptor.Provides::service)) | |
| .forEach(names::remove); | |
| if (!names.isEmpty()) { | |
| log.println(taskHelper.getMessage("warn.provider.notfound", | |
| names.stream().sorted().collect(Collectors.joining(",")))); | |
| } | |
| String msg = String.format("%n%s:", taskHelper.getMessage("suggested.providers.header")); | |
| printProviders(log, msg, mrefs, uses); | |
| } | |
| } | |
| private String getSaveOpts() { | |
| StringBuilder sb = new StringBuilder(); | |
| sb.append('#').append(new Date()).append("\n"); | |
| for (String c : optionsHelper.getInputCommand()) { | |
| sb.append(c).append(" "); | |
| } | |
| return sb.toString(); | |
| } | |
| private static record ImageHelper(Set<Archive> archives, | |
| Platform targetPlatform, | |
| Path packagedModulesPath, | |
| boolean generateRuntimeImage) implements ImageProvider { | |
| @Override | |
| public ExecutableImage retrieve(ImagePluginStack stack) throws IOException { | |
| ExecutableImage image = ImageFileCreator.create(archives, | |
| targetPlatform.arch().byteOrder(), stack, generateRuntimeImage); | |
| if (packagedModulesPath != null) { | |
| // copy the packaged modules to the given path | |
| Files.createDirectories(packagedModulesPath); | |
| for (Archive a : archives) { | |
| Path file = a.getPath(); | |
| Path dest = packagedModulesPath.resolve(file.getFileName()); | |
| Files.copy(file, dest); | |
| } | |
| } | |
| return image; | |
| } | |
| } | |
| } |