1 /*
   2  * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package jdk.tools.jlink.internal;
  26 
  27 import java.io.File;
  28 import java.io.IOException;
  29 import java.io.PrintWriter;
  30 import java.lang.module.Configuration;
  31 import java.lang.module.ModuleFinder;
  32 import java.nio.file.Files;
  33 import java.nio.file.Path;
  34 import java.nio.file.Paths;
  35 import java.text.MessageFormat;
  36 import java.util.ArrayList;
  37 import java.util.Arrays;
  38 import java.util.Collections;
  39 import java.util.HashMap;
  40 import java.util.HashSet;
  41 import java.util.List;
  42 import java.util.Locale;
  43 import java.util.Map;
  44 import java.util.Map.Entry;
  45 import java.util.MissingResourceException;
  46 import java.util.ResourceBundle;
  47 import java.util.Set;
  48 import java.util.stream.Collectors;
  49 import java.util.stream.Stream;
  50 
  51 import jdk.tools.jlink.internal.plugins.ExcludeJmodSectionPlugin;
  52 import jdk.tools.jlink.plugin.Plugin;
  53 import jdk.tools.jlink.plugin.Plugin.Category;
  54 import jdk.tools.jlink.builder.DefaultImageBuilder;
  55 import jdk.tools.jlink.builder.ImageBuilder;
  56 import jdk.tools.jlink.plugin.PluginException;
  57 import jdk.tools.jlink.internal.Jlink.PluginsConfiguration;
  58 import jdk.tools.jlink.internal.plugins.PluginsResourceBundle;
  59 import jdk.tools.jlink.internal.plugins.DefaultCompressPlugin;
  60 import jdk.tools.jlink.internal.plugins.StripDebugPlugin;
  61 import jdk.internal.module.ModulePath;
  62 
  63 /**
  64  *
  65  * JLink and JImage tools shared helper.
  66  */
  67 public final class TaskHelper {
  68 
  69     public static final String JLINK_BUNDLE = "jdk.tools.jlink.resources.jlink";
  70     public static final String JIMAGE_BUNDLE = "jdk.tools.jimage.resources.jimage";
  71 
  72     private static final String DEFAULTS_PROPERTY = "jdk.jlink.defaults";
  73 
  74     public final class BadArgs extends Exception {
  75 
  76         static final long serialVersionUID = 8765093759964640721L;
  77 
  78         private BadArgs(String key, Object... args) {
  79             super(bundleHelper.getMessage(key, args));
  80             this.key = key;
  81             this.args = args;
  82         }
  83 
  84         public BadArgs showUsage(boolean b) {
  85             showUsage = b;
  86             return this;
  87         }
  88         public final String key;
  89         public final Object[] args;
  90         public boolean showUsage;
  91     }
  92 
  93     public static class Option<T> implements Comparable<T> {
  94         public interface Processing<T> {
  95 
  96             void process(T task, String opt, String arg) throws BadArgs;
  97         }
  98 
  99         final boolean hasArg;
 100         final Processing<T> processing;
 101         final boolean hidden;
 102         final String name;
 103         final String shortname;
 104         final boolean terminalOption;
 105 
 106         public Option(boolean hasArg,
 107                       Processing<T> processing,
 108                       boolean hidden,
 109                       String name,
 110                       String shortname,
 111                       boolean isTerminal)
 112         {
 113             if (!name.startsWith("--")) {
 114                 throw new RuntimeException("option name missing --, " + name);
 115             }
 116             if (!shortname.isEmpty() && !shortname.startsWith("-")) {
 117                 throw new RuntimeException("short name missing -, " + shortname);
 118             }
 119 
 120             this.hasArg = hasArg;
 121             this.processing = processing;
 122             this.hidden = hidden;
 123             this.name = name;
 124             this.shortname = shortname;
 125             this.terminalOption = isTerminal;
 126         }
 127 
 128         public Option(boolean hasArg, Processing<T> processing, String name, String shortname, boolean isTerminal) {
 129             this(hasArg, processing, false, name, shortname, isTerminal);
 130         }
 131 
 132         public Option(boolean hasArg, Processing<T> processing, String name, String shortname) {
 133             this(hasArg, processing, false, name, shortname, false);
 134         }
 135 
 136         public Option(boolean hasArg, Processing<T> processing, boolean hidden, String name) {
 137             this(hasArg, processing, hidden, name, "", false);
 138         }
 139 
 140         public Option(boolean hasArg, Processing<T> processing, String name) {
 141             this(hasArg, processing, false, name, "", false);
 142         }
 143 
 144         public boolean isHidden() {
 145             return hidden;
 146         }
 147 
 148         public boolean isTerminal() {
 149             return terminalOption;
 150         }
 151 
 152         public boolean matches(String opt) {
 153             return opt.equals(name) ||
 154                    opt.equals(shortname) ||
 155                    hasArg && opt.startsWith("--") && opt.startsWith(name + "=");
 156          }
 157 
 158         public boolean ignoreRest() {
 159             return false;
 160         }
 161 
 162         void process(T task, String opt, String arg) throws BadArgs {
 163             processing.process(task, opt, arg);
 164         }
 165 
 166         public String getName() {
 167             return name;
 168         }
 169 
 170         public String resourceName() {
 171             return resourcePrefix() + name.substring(2);
 172         }
 173 
 174         public String getShortname() {
 175             return shortname;
 176         }
 177 
 178         public String resourcePrefix() {
 179             return "main.opt.";
 180         }
 181 
 182         @Override
 183         public int compareTo(Object object) {
 184             if (!(object instanceof Option<?>)) {
 185                 throw new RuntimeException("comparing non-Option");
 186             }
 187 
 188             Option<?> option = (Option<?>)object;
 189 
 190             return name.compareTo(option.name);
 191         }
 192 
 193     }
 194 
 195     private static class PluginOption extends Option<PluginsHelper> {
 196         public PluginOption(boolean hasArg,
 197                 Processing<PluginsHelper> processing, boolean hidden, String name, String shortname) {
 198             super(hasArg, processing, hidden, name, shortname, false);
 199         }
 200 
 201         public PluginOption(boolean hasArg,
 202                 Processing<PluginsHelper> processing, boolean hidden, String name) {
 203             super(hasArg, processing, hidden, name, "", false);
 204         }
 205 
 206         public String resourcePrefix() {
 207             return "plugin.opt.";
 208         }
 209     }
 210 
 211     private final class PluginsHelper {
 212 
 213         private ModuleLayer pluginsLayer = ModuleLayer.boot();
 214         private final List<Plugin> plugins;
 215         private String lastSorter;
 216         private boolean listPlugins;
 217         private Path existingImage;
 218 
 219         // plugin to args maps. Each plugin may be used more than once in command line.
 220         // Each such occurrence results in a Map of arguments. So, there could be multiple
 221         // args maps per plugin instance.
 222         private final Map<Plugin, List<Map<String, String>>> pluginToMaps = new HashMap<>();
 223         private final List<PluginOption> pluginsOptions = new ArrayList<>();
 224         private final List<PluginOption> mainOptions = new ArrayList<>();
 225 
 226         private PluginsHelper(String pp) throws BadArgs {
 227 
 228             if (pp != null) {
 229                 String[] dirs = pp.split(File.pathSeparator);
 230                 List<Path> paths = new ArrayList<>(dirs.length);
 231                 for (String dir : dirs) {
 232                     paths.add(Paths.get(dir));
 233                 }
 234 
 235                 pluginsLayer = createPluginsLayer(paths);
 236             }
 237 
 238             plugins = PluginRepository.getPlugins(pluginsLayer);
 239 
 240             Set<String> optionsSeen = new HashSet<>();
 241             for (Plugin plugin : plugins) {
 242                 if (!Utils.isDisabled(plugin)) {
 243                     addOrderedPluginOptions(plugin, optionsSeen);
 244                 }
 245             }
 246             mainOptions.add(new PluginOption(true, (task, opt, arg) -> {
 247                     for (Plugin plugin : plugins) {
 248                         if (plugin.getName().equals(arg)) {
 249                             pluginToMaps.remove(plugin);
 250                             return;
 251                         }
 252                     }
 253                     throw newBadArgs("err.no.such.plugin", arg);
 254                 },
 255                 false, "--disable-plugin"));
 256             mainOptions.add(new PluginOption(true, (task, opt, arg) -> {
 257                 Path path = Paths.get(arg);
 258                 if (!Files.exists(path) || !Files.isDirectory(path)) {
 259                     throw newBadArgs("err.image.must.exist", path);
 260                 }
 261                 existingImage = path.toAbsolutePath();
 262             }, true, "--post-process-path"));
 263             mainOptions.add(new PluginOption(true,
 264                     (task, opt, arg) -> {
 265                         lastSorter = arg;
 266                     },
 267                     true, "--resources-last-sorter"));
 268             mainOptions.add(new PluginOption(false,
 269                     (task, opt, arg) -> {
 270                         listPlugins = true;
 271                     },
 272                     false, "--list-plugins"));
 273         }
 274 
 275         private List<Map<String, String>> argListFor(Plugin plugin) {
 276             List<Map<String, String>> mapList = pluginToMaps.get(plugin);
 277             if (mapList == null) {
 278                 mapList = new ArrayList<>();
 279                 pluginToMaps.put(plugin, mapList);
 280             }
 281             return mapList;
 282         }
 283 
 284         private void addEmptyArgumentMap(Plugin plugin) {
 285             argListFor(plugin).add(Collections.emptyMap());
 286         }
 287 
 288         private Map<String, String> addArgumentMap(Plugin plugin) {
 289             Map<String, String> map = new HashMap<>();
 290             argListFor(plugin).add(map);
 291             return map;
 292         }
 293 
 294         private void addOrderedPluginOptions(Plugin plugin,
 295             Set<String> optionsSeen) throws BadArgs {
 296             String option = plugin.getOption();
 297             if (option == null) {
 298                 return;
 299             }
 300 
 301             // make sure that more than one plugin does not use the same option!
 302             if (optionsSeen.contains(option)) {
 303                 throw new BadArgs("err.plugin.mutiple.options",
 304                         option);
 305             }
 306             optionsSeen.add(option);
 307 
 308             PluginOption plugOption
 309                     = new PluginOption(plugin.hasArguments(),
 310                             (task, opt, arg) -> {
 311                                 if (!Utils.isFunctional(plugin)) {
 312                                     throw newBadArgs("err.provider.not.functional",
 313                                             option);
 314                                 }
 315 
 316                                 if (! plugin.hasArguments()) {
 317                                     addEmptyArgumentMap(plugin);
 318                                     return;
 319                                 }
 320 
 321                                 Map<String, String> m = addArgumentMap(plugin);
 322                                 // handle one or more arguments
 323                                 if (arg.indexOf(':') == -1) {
 324                                     // single argument case
 325                                     m.put(option, arg);
 326                                 } else {
 327                                     // This option can accept more than one arguments
 328                                     // like --option_name=arg_value:arg2=value2:arg3=value3
 329 
 330                                     // ":" followed by word char condition takes care of args that
 331                                     // like Windows absolute paths "C:\foo", "C:/foo" [cygwin] etc.
 332                                     // This enforces that key names start with a word character.
 333                                     String[] args = arg.split(":(?=\\w)", -1);
 334                                     String firstArg = args[0];
 335                                     if (firstArg.isEmpty()) {
 336                                         throw newBadArgs("err.provider.additional.arg.error",
 337                                             option, arg);
 338                                     }
 339                                     m.put(option, firstArg);
 340                                     // process the additional arguments
 341                                     for (int i = 1; i < args.length; i++) {
 342                                         String addArg = args[i];
 343                                         int eqIdx = addArg.indexOf('=');
 344                                         if (eqIdx == -1) {
 345                                             throw newBadArgs("err.provider.additional.arg.error",
 346                                                 option, arg);
 347                                         }
 348 
 349                                         String addArgName = addArg.substring(0, eqIdx);
 350                                         String addArgValue = addArg.substring(eqIdx+1);
 351                                         if (addArgName.isEmpty() || addArgValue.isEmpty()) {
 352                                             throw newBadArgs("err.provider.additional.arg.error",
 353                                                 option, arg);
 354                                         }
 355                                         m.put(addArgName, addArgValue);
 356                                     }
 357                                 }
 358                             },
 359                             false, "--" + option);
 360             pluginsOptions.add(plugOption);
 361 
 362             if (Utils.isFunctional(plugin)) {
 363                 if (Utils.isAutoEnabled(plugin)) {
 364                     addEmptyArgumentMap(plugin);
 365                 }
 366 
 367                 if (plugin instanceof DefaultCompressPlugin) {
 368                     plugOption
 369                         = new PluginOption(false,
 370                             (task, opt, arg) -> {
 371                                 Map<String, String> m = addArgumentMap(plugin);
 372                                 m.put(DefaultCompressPlugin.NAME, DefaultCompressPlugin.LEVEL_2);
 373                             }, false, "--compress", "-c");
 374                     mainOptions.add(plugOption);
 375                 } else if (plugin instanceof StripDebugPlugin) {
 376                     plugOption
 377                         = new PluginOption(false,
 378                             (task, opt, arg) -> {
 379                                 addArgumentMap(plugin);
 380                             }, false, "--strip-debug", "-G");
 381                     mainOptions.add(plugOption);
 382                 } else if (plugin instanceof ExcludeJmodSectionPlugin) {
 383                     plugOption = new PluginOption(false, (task, opt, arg) -> {
 384                             Map<String, String> m = addArgumentMap(plugin);
 385                             m.put(ExcludeJmodSectionPlugin.NAME,
 386                                   ExcludeJmodSectionPlugin.MAN_PAGES);
 387                         }, false, "--no-man-pages");
 388                     mainOptions.add(plugOption);
 389 
 390                     plugOption = new PluginOption(false, (task, opt, arg) -> {
 391                         Map<String, String> m = addArgumentMap(plugin);
 392                         m.put(ExcludeJmodSectionPlugin.NAME,
 393                               ExcludeJmodSectionPlugin.INCLUDE_HEADER_FILES);
 394                     }, false, "--no-header-files");
 395                     mainOptions.add(plugOption);
 396                 }
 397             }
 398         }
 399 
 400         private PluginOption getOption(String name) throws BadArgs {
 401             for (PluginOption o : pluginsOptions) {
 402                 if (o.matches(name)) {
 403                     return o;
 404                 }
 405             }
 406             for (PluginOption o : mainOptions) {
 407                 if (o.matches(name)) {
 408                     return o;
 409                 }
 410             }
 411             return null;
 412         }
 413 
 414         private PluginsConfiguration getPluginsConfig(Path output, Map<String, String> launchers
 415                     ) throws IOException, BadArgs {
 416             if (output != null) {
 417                 if (Files.exists(output)) {
 418                     throw new PluginException(PluginsResourceBundle.
 419                             getMessage("err.dir.already.exits", output));
 420                 }
 421             }
 422 
 423             List<Plugin> pluginsList = new ArrayList<>();
 424             for (Entry<Plugin, List<Map<String, String>>> entry : pluginToMaps.entrySet()) {
 425                 Plugin plugin = entry.getKey();
 426                 List<Map<String, String>> argsMaps = entry.getValue();
 427 
 428                 // same plugin option may be used multiple times in command line.
 429                 // we call configure once for each occurrence. It is upto the plugin
 430                 // to 'merge' and/or 'override' arguments.
 431                 for (Map<String, String> map : argsMaps) {
 432                     try {
 433                         plugin.configure(Collections.unmodifiableMap(map));
 434                     } catch (IllegalArgumentException e) {
 435                         if (JlinkTask.DEBUG) {
 436                             System.err.println("Plugin " + plugin.getName() + " threw exception with config: " + map);
 437                             e.printStackTrace();
 438                         }
 439                         throw e;
 440                     }
 441                 }
 442 
 443                 if (!Utils.isDisabled(plugin)) {
 444                     pluginsList.add(plugin);
 445                 }
 446             }
 447 
 448             // recreate or postprocessing don't require an output directory.
 449             ImageBuilder builder = null;
 450             if (output != null) {
 451                 builder = new DefaultImageBuilder(output, launchers);
 452             }
 453 
 454             return new Jlink.PluginsConfiguration(pluginsList,
 455                     builder, lastSorter);
 456         }
 457     }
 458 
 459     private static final class ResourceBundleHelper {
 460 
 461         private final ResourceBundle bundle;
 462         private final ResourceBundle pluginBundle;
 463 
 464         ResourceBundleHelper(String path) {
 465             Locale locale = Locale.getDefault();
 466             try {
 467                 bundle = ResourceBundle.getBundle(path, locale);
 468                 pluginBundle = ResourceBundle.getBundle("jdk.tools.jlink.resources.plugins", locale);
 469             } catch (MissingResourceException e) {
 470                 throw new InternalError("Cannot find jlink resource bundle for locale " + locale);
 471             }
 472         }
 473 
 474         String getMessage(String key, Object... args) {
 475             String val;
 476             try {
 477                 val = bundle.getString(key);
 478             } catch (MissingResourceException e) {
 479                 // XXX OK, check in plugin bundle
 480                 val = pluginBundle.getString(key);
 481             }
 482             return MessageFormat.format(val, args);
 483         }
 484 
 485     }
 486 
 487     public final class OptionsHelper<T> {
 488 
 489         private final List<Option<T>> options;
 490         private String[] command;
 491         private String defaults;
 492 
 493         OptionsHelper(List<Option<T>> options) {
 494             this.options = options;
 495         }
 496 
 497         private boolean hasArgument(String optionName) throws BadArgs {
 498             Option<?> opt = getOption(optionName);
 499             if (opt == null) {
 500                 opt = pluginOptions.getOption(optionName);
 501                 if (opt == null) {
 502                     throw new BadArgs("err.unknown.option", optionName).
 503                             showUsage(true);
 504                 }
 505             }
 506             return opt.hasArg;
 507         }
 508 
 509         public boolean shouldListPlugins() {
 510             return pluginOptions.listPlugins;
 511         }
 512 
 513         private String getPluginsPath(String[] args) throws BadArgs {
 514             return null;
 515         }
 516 
 517         /**
 518          * Handles all options.  This method stops processing the argument
 519          * at the first non-option argument i.e. not starts with `-`, or
 520          * at the first terminal option and returns the remaining arguments,
 521          * if any.
 522          */
 523         public List<String> handleOptions(T task, String[] args) throws BadArgs {
 524             // findbugs warning, copy instead of keeping a reference.
 525             command = Arrays.copyOf(args, args.length);
 526 
 527             // Must extract it prior to do any option analysis.
 528             // Required to interpret custom plugin options.
 529             // Unit tests can call Task multiple time in same JVM.
 530             pluginOptions = new PluginsHelper(null);
 531 
 532             // process options
 533             for (int i = 0; i < args.length; i++) {
 534                 if (args[i].startsWith("-")) {
 535                     String name = args[i];
 536                     PluginOption pluginOption = null;
 537                     Option<T> option = getOption(name);
 538                     if (option == null) {
 539                         pluginOption = pluginOptions.getOption(name);
 540                         if (pluginOption == null) {
 541                             throw new BadArgs("err.unknown.option", name).
 542                                     showUsage(true);
 543                         }
 544                     }
 545                     Option<?> opt = pluginOption == null ? option : pluginOption;
 546                     String param = null;
 547                     if (opt.hasArg) {
 548                         if (name.startsWith("--") && name.indexOf('=') > 0) {
 549                             param = name.substring(name.indexOf('=') + 1,
 550                                     name.length());
 551                         } else if (i + 1 < args.length) {
 552                             param = args[++i];
 553                         }
 554                         if (param == null || param.isEmpty()
 555                                 || (param.length() >= 2 && param.charAt(0) == '-'
 556                                 && param.charAt(1) == '-')) {
 557                             throw new BadArgs("err.missing.arg", name).
 558                                     showUsage(true);
 559                         }
 560                     }
 561                     if (pluginOption != null) {
 562                         pluginOption.process(pluginOptions, name, param);
 563                     } else {
 564                         option.process(task, name, param);
 565                         if (option.isTerminal()) {
 566                             return ++i < args.length
 567                                         ? Stream.of(Arrays.copyOfRange(args, i, args.length))
 568                                                 .collect(Collectors.toList())
 569                                         : Collections.emptyList();
 570 
 571                         }
 572                     }
 573                     if (opt.ignoreRest()) {
 574                         i = args.length;
 575                     }
 576                 } else {
 577                     return Stream.of(Arrays.copyOfRange(args, i, args.length))
 578                                  .collect(Collectors.toList());
 579                 }
 580             }
 581             return Collections.emptyList();
 582         }
 583 
 584         private Option<T> getOption(String name) {
 585             for (Option<T> o : options) {
 586                 if (o.matches(name)) {
 587                     return o;
 588                 }
 589             }
 590             return null;
 591         }
 592 
 593         public void showHelp(String progName) {
 594             log.println(bundleHelper.getMessage("main.usage", progName));
 595             Stream.concat(options.stream(), pluginOptions.mainOptions.stream())
 596                 .filter(option -> !option.isHidden())
 597                 .sorted()
 598                 .forEach(option -> {
 599                      log.println(bundleHelper.getMessage(option.resourceName()));
 600                 });
 601 
 602             log.println(bundleHelper.getMessage("main.command.files"));
 603         }
 604 
 605         public void listPlugins() {
 606             log.println("\n" + bundleHelper.getMessage("main.extended.help"));
 607             List<Plugin> pluginList = PluginRepository.
 608                     getPlugins(pluginOptions.pluginsLayer);
 609 
 610             for (Plugin plugin : Utils.getSortedPlugins(pluginList)) {
 611                 showPlugin(plugin, log);
 612             }
 613 
 614             log.println("\n" + bundleHelper.getMessage("main.extended.help.footer"));
 615         }
 616 
 617         private void showPlugin(Plugin plugin, PrintWriter log) {
 618             if (showsPlugin(plugin)) {
 619                 log.println("\n" + bundleHelper.getMessage("main.plugin.name")
 620                         + ": " + plugin.getName());
 621 
 622                 // print verbose details for non-builtin plugins
 623                 if (!Utils.isBuiltin(plugin)) {
 624                     log.println(bundleHelper.getMessage("main.plugin.class")
 625                          + ": " + plugin.getClass().getName());
 626                     log.println(bundleHelper.getMessage("main.plugin.module")
 627                          + ": " + plugin.getClass().getModule().getName());
 628                     Category category = plugin.getType();
 629                     log.println(bundleHelper.getMessage("main.plugin.category")
 630                          + ": " + category.getName());
 631                     log.println(bundleHelper.getMessage("main.plugin.state")
 632                         + ": " + plugin.getStateDescription());
 633                 }
 634 
 635                 String option = plugin.getOption();
 636                 if (option != null) {
 637                     log.println(bundleHelper.getMessage("main.plugin.option")
 638                         + ": --" + plugin.getOption()
 639                         + (plugin.hasArguments()? ("=" + plugin.getArgumentsDescription()) : ""));
 640                 }
 641 
 642                 // description can be long spanning more than one line and so
 643                 // print a newline after description label.
 644                 log.println(bundleHelper.getMessage("main.plugin.description")
 645                         + ": " + plugin.getDescription());
 646             }
 647         }
 648 
 649         String[] getInputCommand() {
 650             return command;
 651         }
 652 
 653         String getDefaults() {
 654             return defaults;
 655         }
 656 
 657         public ModuleLayer getPluginsLayer() {
 658             return pluginOptions.pluginsLayer;
 659         }
 660     }
 661 
 662     private PluginsHelper pluginOptions;
 663     private PrintWriter log;
 664     private final ResourceBundleHelper bundleHelper;
 665 
 666     public TaskHelper(String path) {
 667         if (!JLINK_BUNDLE.equals(path) && !JIMAGE_BUNDLE.equals(path)) {
 668             throw new IllegalArgumentException("Invalid Bundle");
 669         }
 670         this.bundleHelper = new ResourceBundleHelper(path);
 671     }
 672 
 673     public <T> OptionsHelper<T> newOptionsHelper(Class<T> clazz,
 674             Option<?>[] options) {
 675         List<Option<T>> optionsList = new ArrayList<>();
 676         for (Option<?> o : options) {
 677             @SuppressWarnings("unchecked")
 678             Option<T> opt = (Option<T>) o;
 679             optionsList.add(opt);
 680         }
 681         return new OptionsHelper<>(optionsList);
 682     }
 683 
 684     public BadArgs newBadArgs(String key, Object... args) {
 685         return new BadArgs(key, args);
 686     }
 687 
 688     public String getMessage(String key, Object... args) {
 689         return bundleHelper.getMessage(key, args);
 690     }
 691 
 692     public void setLog(PrintWriter log) {
 693         this.log = log;
 694     }
 695 
 696     public void reportError(String key, Object... args) {
 697         log.println(bundleHelper.getMessage("error.prefix") + " "
 698                 + bundleHelper.getMessage(key, args));
 699     }
 700 
 701     public void reportUnknownError(String message) {
 702         log.println(bundleHelper.getMessage("error.prefix") + " " + message);
 703     }
 704 
 705     public void warning(String key, Object... args) {
 706         log.println(bundleHelper.getMessage("warn.prefix") + " "
 707                 + bundleHelper.getMessage(key, args));
 708     }
 709 
 710     public PluginsConfiguration getPluginsConfig(Path output, Map<String, String> launchers)
 711             throws IOException, BadArgs {
 712         return pluginOptions.getPluginsConfig(output, launchers);
 713     }
 714 
 715     public Path getExistingImage() {
 716         return pluginOptions.existingImage;
 717     }
 718 
 719     public void showVersion(boolean full) {
 720         log.println(version(full ? "full" : "release"));
 721     }
 722 
 723     public String version(String key) {
 724         return System.getProperty("java.version");
 725     }
 726 
 727     static ModuleLayer createPluginsLayer(List<Path> paths) {
 728 
 729         Path[] dirs = paths.toArray(new Path[0]);
 730         ModuleFinder finder = ModulePath.of(Runtime.version(), true, dirs);
 731         Configuration bootConfiguration = ModuleLayer.boot().configuration();
 732         try {
 733             Configuration cf = bootConfiguration
 734                 .resolveAndBind(ModuleFinder.of(),
 735                                 finder,
 736                                 Collections.emptySet());
 737             ClassLoader scl = ClassLoader.getSystemClassLoader();
 738             return ModuleLayer.boot().defineModulesWithOneLoader(cf, scl);
 739         } catch (Exception ex) {
 740             // Malformed plugin modules (e.g.: same package in multiple modules).
 741             throw new PluginException("Invalid modules in the plugins path: " + ex);
 742         }
 743     }
 744 
 745     // Display all plugins
 746     private static boolean showsPlugin(Plugin plugin) {
 747         return (!Utils.isDisabled(plugin) && plugin.getOption() != null);
 748     }
 749 }