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.io.UncheckedIOException;
31 import java.lang.module.Configuration;
32 import java.lang.module.FindException;
33 import java.lang.module.ModuleDescriptor;
34 import java.lang.module.ModuleFinder;
35 import java.lang.module.ModuleReference;
36 import java.lang.module.ResolutionException;
37 import java.lang.module.ResolvedModule;
38 import java.net.URI;
39 import java.nio.ByteOrder;
40 import java.nio.file.Files;
41 import java.nio.file.Path;
42 import java.nio.file.Paths;
43 import java.util.ArrayList;
44 import java.util.Arrays;
45 import java.util.Collection;
46 import java.util.Collections;
47 import java.util.Comparator;
48 import java.util.Date;
49 import java.util.HashMap;
50 import java.util.HashSet;
51 import java.util.List;
52 import java.util.Locale;
53 import java.util.Map;
54 import java.util.Objects;
55 import java.util.Optional;
56 import java.util.Set;
57 import java.util.stream.Collectors;
58 import java.util.stream.Stream;
59
60 import jdk.tools.jlink.internal.TaskHelper.BadArgs;
61 import static jdk.tools.jlink.internal.TaskHelper.JLINK_BUNDLE;
62 import jdk.tools.jlink.internal.Jlink.JlinkConfiguration;
63 import jdk.tools.jlink.internal.Jlink.PluginsConfiguration;
64 import jdk.tools.jlink.internal.TaskHelper.Option;
65 import jdk.tools.jlink.internal.TaskHelper.OptionsHelper;
66 import jdk.tools.jlink.internal.ImagePluginStack.ImageProvider;
67 import jdk.tools.jlink.plugin.PluginException;
68 import jdk.tools.jlink.builder.DefaultImageBuilder;
69 import jdk.tools.jlink.plugin.Plugin;
70 import jdk.internal.module.ModulePath;
71 import jdk.internal.module.ModuleResolution;
72
73 /**
74 * Implementation for the jlink tool.
75 *
76 * ## Should use jdk.joptsimple some day.
77 */
78 public class JlinkTask {
79 static final boolean DEBUG = Boolean.getBoolean("jlink.debug");
80
81 // jlink API ignores by default. Remove when signing is implemented.
82 static final boolean IGNORE_SIGNING_DEFAULT = true;
83
84 private static final TaskHelper taskHelper
85 = new TaskHelper(JLINK_BUNDLE);
86
87 private static final Option<?>[] recognizedOptions = {
88 new Option<JlinkTask>(false, (task, opt, arg) -> {
89 task.options.help = true;
90 }, "--help", "-h"),
91 new Option<JlinkTask>(true, (task, opt, arg) -> {
92 // if used multiple times, the last one wins!
93 // So, clear previous values, if any.
94 task.options.modulePath.clear();
95 String[] dirs = arg.split(File.pathSeparator);
96 int i = 0;
97 Arrays.stream(dirs)
98 .map(Paths::get)
99 .forEach(task.options.modulePath::add);
100 }, "--module-path", "-p"),
101 new Option<JlinkTask>(true, (task, opt, arg) -> {
102 // if used multiple times, the last one wins!
103 // So, clear previous values, if any.
104 task.options.limitMods.clear();
105 for (String mn : arg.split(",")) {
106 if (mn.isEmpty()) {
107 throw taskHelper.newBadArgs("err.mods.must.be.specified",
108 "--limit-modules");
109 }
110 task.options.limitMods.add(mn);
111 }
112 }, "--limit-modules"),
113 new Option<JlinkTask>(true, (task, opt, arg) -> {
114 for (String mn : arg.split(",")) {
115 if (mn.isEmpty()) {
116 throw taskHelper.newBadArgs("err.mods.must.be.specified",
117 "--add-modules");
118 }
119 task.options.addMods.add(mn);
120 }
121 }, "--add-modules"),
122 new Option<JlinkTask>(true, (task, opt, arg) -> {
123 Path path = Paths.get(arg);
124 task.options.output = path;
125 }, "--output"),
126 new Option<JlinkTask>(false, (task, opt, arg) -> {
127 task.options.bindServices = true;
128 }, "--bind-services"),
129 new Option<JlinkTask>(false, (task, opt, arg) -> {
130 task.options.suggestProviders = true;
131 }, "--suggest-providers", "", true),
132 new Option<JlinkTask>(true, (task, opt, arg) -> {
133 String[] values = arg.split("=");
134 // check values
135 if (values.length != 2 || values[0].isEmpty() || values[1].isEmpty()) {
136 throw taskHelper.newBadArgs("err.launcher.value.format", arg);
137 } else {
138 String commandName = values[0];
139 String moduleAndMain = values[1];
140 int idx = moduleAndMain.indexOf("/");
141 if (idx != -1) {
142 if (moduleAndMain.substring(0, idx).isEmpty()) {
143 throw taskHelper.newBadArgs("err.launcher.module.name.empty", arg);
144 }
145
146 if (moduleAndMain.substring(idx + 1).isEmpty()) {
147 throw taskHelper.newBadArgs("err.launcher.main.class.empty", arg);
148 }
149 }
150 task.options.launchers.put(commandName, moduleAndMain);
151 }
152 }, "--launcher"),
153 new Option<JlinkTask>(true, (task, opt, arg) -> {
154 if ("little".equals(arg)) {
155 task.options.endian = ByteOrder.LITTLE_ENDIAN;
156 } else if ("big".equals(arg)) {
157 task.options.endian = ByteOrder.BIG_ENDIAN;
158 } else {
159 throw taskHelper.newBadArgs("err.unknown.byte.order", arg);
160 }
161 }, "--endian"),
162 new Option<JlinkTask>(false, (task, opt, arg) -> {
163 task.options.verbose = true;
164 }, "--verbose", "-v"),
165 new Option<JlinkTask>(false, (task, opt, arg) -> {
166 task.options.version = true;
167 }, "--version"),
168 new Option<JlinkTask>(true, (task, opt, arg) -> {
169 Path path = Paths.get(arg);
170 if (Files.exists(path)) {
171 throw taskHelper.newBadArgs("err.dir.exists", path);
172 }
173 task.options.packagedModulesPath = path;
174 }, true, "--keep-packaged-modules"),
175 new Option<JlinkTask>(true, (task, opt, arg) -> {
176 task.options.saveoptsfile = arg;
177 }, "--save-opts"),
178 new Option<JlinkTask>(false, (task, opt, arg) -> {
179 task.options.fullVersion = true;
180 }, true, "--full-version"),
181 new Option<JlinkTask>(false, (task, opt, arg) -> {
182 task.options.ignoreSigning = true;
183 }, "--ignore-signing-information"),};
184
185 private static final String PROGNAME = "jlink";
186 private final OptionsValues options = new OptionsValues();
187
188 private static final OptionsHelper<JlinkTask> optionsHelper
189 = taskHelper.newOptionsHelper(JlinkTask.class, recognizedOptions);
190 private PrintWriter log;
191
192 void setLog(PrintWriter out, PrintWriter err) {
193 log = out;
194 taskHelper.setLog(log);
195 }
196
197 /**
198 * Result codes.
199 */
200 static final int
201 EXIT_OK = 0, // Completed with no errors.
202 EXIT_ERROR = 1, // Completed but reported errors.
203 EXIT_CMDERR = 2, // Bad command-line arguments
204 EXIT_SYSERR = 3, // System error or resource exhaustion.
205 EXIT_ABNORMAL = 4;// terminated abnormally
206
207 static class OptionsValues {
208 boolean help;
209 String saveoptsfile;
210 boolean verbose;
211 boolean version;
212 boolean fullVersion;
213 final List<Path> modulePath = new ArrayList<>();
214 final Set<String> limitMods = new HashSet<>();
215 final Set<String> addMods = new HashSet<>();
216 Path output;
217 final Map<String, String> launchers = new HashMap<>();
218 Path packagedModulesPath;
219 ByteOrder endian = ByteOrder.nativeOrder();
220 boolean ignoreSigning = false;
221 boolean bindServices = false;
222 boolean suggestProviders = false;
223 }
224
225 int run(String[] args) {
226 if (log == null) {
227 setLog(new PrintWriter(System.out, true),
228 new PrintWriter(System.err, true));
229 }
230 try {
231 List<String> remaining = optionsHelper.handleOptions(this, args);
232 if (remaining.size() > 0 && !options.suggestProviders) {
233 throw taskHelper.newBadArgs("err.orphan.arguments", toString(remaining))
234 .showUsage(true);
235 }
236 if (options.help) {
237 optionsHelper.showHelp(PROGNAME);
238 return EXIT_OK;
239 }
240 if (optionsHelper.shouldListPlugins()) {
241 optionsHelper.listPlugins();
242 return EXIT_OK;
243 }
244 if (options.version || options.fullVersion) {
245 taskHelper.showVersion(options.fullVersion);
246 return EXIT_OK;
247 }
248
249 if (taskHelper.getExistingImage() != null) {
250 postProcessOnly(taskHelper.getExistingImage());
251 return EXIT_OK;
252 }
253
254
255 if (options.modulePath.isEmpty()) {
256 // no --module-path specified - try to set $JAVA_HOME/jmods if that exists
257 Path jmods = getDefaultModulePath();
258 if (jmods != null) {
259 options.modulePath.add(jmods);
260 }
261
262 if (options.modulePath.isEmpty()) {
263 throw taskHelper.newBadArgs("err.modulepath.must.be.specified")
264 .showUsage(true);
265 }
266 }
267
268 JlinkConfiguration config = initJlinkConfig();
269 if (options.suggestProviders) {
270 suggestProviders(config, remaining);
271 } else {
272 createImage(config);
273 if (options.saveoptsfile != null) {
274 Files.write(Paths.get(options.saveoptsfile), getSaveOpts().getBytes());
275 }
276 }
277
278 return EXIT_OK;
279 } catch (PluginException | IllegalArgumentException |
280 UncheckedIOException |IOException | FindException | ResolutionException e) {
281 log.println(taskHelper.getMessage("error.prefix") + " " + e.getMessage());
282 if (DEBUG) {
283 e.printStackTrace(log);
284 }
285 return EXIT_ERROR;
286 } catch (BadArgs e) {
287 taskHelper.reportError(e.key, e.args);
288 if (e.showUsage) {
289 log.println(taskHelper.getMessage("main.usage.summary", PROGNAME));
290 }
291 if (DEBUG) {
292 e.printStackTrace(log);
293 }
294 return EXIT_CMDERR;
295 } catch (Throwable x) {
296 log.println(taskHelper.getMessage("error.prefix") + " " + x.getMessage());
297 x.printStackTrace(log);
298 return EXIT_ABNORMAL;
299 } finally {
300 log.flush();
301 }
302 }
303
304 /*
305 * Jlink API entry point.
306 */
307 public static void createImage(JlinkConfiguration config,
308 PluginsConfiguration plugins)
309 throws Exception {
310 Objects.requireNonNull(config);
311 Objects.requireNonNull(config.getOutput());
312 plugins = plugins == null ? new PluginsConfiguration() : plugins;
313
314 // First create the image provider
315 ImageProvider imageProvider =
316 createImageProvider(config,
317 null,
318 IGNORE_SIGNING_DEFAULT,
319 false,
320 false,
321 null);
322
323 // Then create the Plugin Stack
324 ImagePluginStack stack = ImagePluginConfiguration.parseConfiguration(plugins);
325
326 //Ask the stack to proceed;
327 stack.operate(imageProvider);
328 }
329
330 /*
331 * Jlink API entry point.
332 */
333 public static void postProcessImage(ExecutableImage image, List<Plugin> postProcessorPlugins)
334 throws Exception {
335 Objects.requireNonNull(image);
336 Objects.requireNonNull(postProcessorPlugins);
337 PluginsConfiguration config = new PluginsConfiguration(postProcessorPlugins);
338 ImagePluginStack stack = ImagePluginConfiguration.
339 parseConfiguration(config);
340
341 stack.operate((ImagePluginStack stack1) -> image);
342 }
343
344 private void postProcessOnly(Path existingImage) throws Exception {
345 PluginsConfiguration config = taskHelper.getPluginsConfig(null, null);
346 ExecutableImage img = DefaultImageBuilder.getExecutableImage(existingImage);
347 if (img == null) {
348 throw taskHelper.newBadArgs("err.existing.image.invalid");
349 }
350 postProcessImage(img, config.getPlugins());
351 }
352
353 // the token for "all modules on the module path"
354 private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH";
355 private JlinkConfiguration initJlinkConfig() throws BadArgs {
356 Set<String> roots = new HashSet<>();
357 for (String mod : options.addMods) {
358 if (mod.equals(ALL_MODULE_PATH)) {
359 ModuleFinder finder = newModuleFinder(options.modulePath, options.limitMods, Set.of());
360 // all observable modules are roots
361 finder.findAll()
362 .stream()
363 .map(ModuleReference::descriptor)
364 .map(ModuleDescriptor::name)
365 .forEach(mn -> roots.add(mn));
366 } else {
367 roots.add(mod);
368 }
369 }
370
371 ModuleFinder finder = newModuleFinder(options.modulePath, options.limitMods, roots);
372 if (!finder.find("java.base").isPresent()) {
373 Path defModPath = getDefaultModulePath();
374 if (defModPath != null) {
375 options.modulePath.add(defModPath);
376 }
377 finder = newModuleFinder(options.modulePath, options.limitMods, roots);
378 }
379
380 return new JlinkConfiguration(options.output,
381 roots,
382 options.endian,
383 finder);
384 }
385
386 private void createImage(JlinkConfiguration config) throws Exception {
387 if (options.output == null) {
388 throw taskHelper.newBadArgs("err.output.must.be.specified").showUsage(true);
389 }
390 if (options.addMods.isEmpty()) {
391 throw taskHelper.newBadArgs("err.mods.must.be.specified", "--add-modules")
392 .showUsage(true);
393 }
394
395 // First create the image provider
396 ImageProvider imageProvider = createImageProvider(config,
397 options.packagedModulesPath,
398 options.ignoreSigning,
399 options.bindServices,
400 options.verbose,
401 log);
402
403 // Then create the Plugin Stack
404 ImagePluginStack stack = ImagePluginConfiguration.parseConfiguration(
405 taskHelper.getPluginsConfig(options.output, options.launchers));
406
407 //Ask the stack to proceed
408 stack.operate(imageProvider);
409 }
410
411 /**
412 * @return the system module path or null
413 */
414 public static Path getDefaultModulePath() {
415 Path jmods = Paths.get(System.getProperty("java.home"), "jmods");
416 return Files.isDirectory(jmods)? jmods : null;
417 }
418
419 /*
420 * Returns a module finder of the given module path that limits
421 * the observable modules to those in the transitive closure of
422 * the modules specified in {@code limitMods} plus other modules
423 * specified in the {@code roots} set.
424 *
425 * @throws IllegalArgumentException if java.base module is present
426 * but its descriptor has no version
427 */
428 public static ModuleFinder newModuleFinder(List<Path> paths,
429 Set<String> limitMods,
430 Set<String> roots)
431 {
432 if (Objects.requireNonNull(paths).isEmpty()) {
433 throw new IllegalArgumentException("Empty module path");
434 }
435
436 Path[] entries = paths.toArray(new Path[0]);
437 Runtime.Version version = Runtime.version();
438 ModuleFinder finder = ModulePath.of(version, true, entries);
439
440 if (finder.find("java.base").isPresent()) {
441 // use the version of java.base module, if present, as
442 // the release version for multi-release JAR files
443 ModuleDescriptor.Version v = finder.find("java.base").get()
444 .descriptor().version().orElseThrow(() ->
445 new IllegalArgumentException("No version in java.base descriptor")
446 );
447
448 // java.base version is different than the current runtime version
449 version = Runtime.Version.parse(v.toString());
450 if (Runtime.version().major() != version.major()) {
451 finder = ModulePath.of(version, true, entries);
452 }
453 }
454
455 // if limitmods is specified then limit the universe
456 if (limitMods != null && !limitMods.isEmpty()) {
457 finder = limitFinder(finder, limitMods, Objects.requireNonNull(roots));
458 }
459 return finder;
460 }
461
462 private static Path toPathLocation(ResolvedModule m) {
463 Optional<URI> ouri = m.reference().location();
464 if (!ouri.isPresent())
465 throw new InternalError(m + " does not have a location");
466 URI uri = ouri.get();
467 return Paths.get(uri);
468 }
469
470
471 private static ImageProvider createImageProvider(JlinkConfiguration config,
472 Path retainModulesPath,
473 boolean ignoreSigning,
474 boolean bindService,
475 boolean verbose,
476 PrintWriter log)
477 throws IOException
478 {
479 Configuration cf = bindService ? config.resolveAndBind()
480 : config.resolve();
481
482 cf.modules().stream()
483 .map(ResolvedModule::reference)
484 .filter(mref -> mref.descriptor().isAutomatic())
485 .findAny()
486 .ifPresent(mref -> {
487 String loc = mref.location().map(URI::toString).orElse("<unknown>");
488 throw new IllegalArgumentException(
489 taskHelper.getMessage("err.automatic.module", mref.descriptor().name(), loc));
490 });
491
492 if (verbose && log != null) {
493 // print modules to be linked in
494 cf.modules().stream()
495 .sorted(Comparator.comparing(ResolvedModule::name))
496 .forEach(rm -> log.format("%s %s%n",
497 rm.name(), rm.reference().location().get()));
498
499 // print provider info
500 Set<ModuleReference> references = cf.modules().stream()
501 .map(ResolvedModule::reference).collect(Collectors.toSet());
502
503 String msg = String.format("%n%s:", taskHelper.getMessage("providers.header"));
504 printProviders(log, msg, references);
505 }
506
507 // emit a warning for any incubating modules in the configuration
508 if (log != null) {
509 String im = cf.modules()
510 .stream()
511 .map(ResolvedModule::reference)
512 .filter(ModuleResolution::hasIncubatingWarning)
513 .map(ModuleReference::descriptor)
514 .map(ModuleDescriptor::name)
515 .collect(Collectors.joining(", "));
516
517 if (!"".equals(im))
518 log.println("WARNING: Using incubator modules: " + im);
519 }
520
521 Map<String, Path> mods = cf.modules().stream()
522 .collect(Collectors.toMap(ResolvedModule::name, JlinkTask::toPathLocation));
523 return new ImageHelper(cf, mods, config.getByteOrder(), retainModulesPath, ignoreSigning);
524 }
525
526 /*
527 * Returns a ModuleFinder that limits observability to the given root
528 * modules, their transitive dependences, plus a set of other modules.
529 */
530 public static ModuleFinder limitFinder(ModuleFinder finder,
531 Set<String> roots,
532 Set<String> otherMods) {
533
534 // resolve all root modules
535 Configuration cf = Configuration.empty()
536 .resolve(finder,
537 ModuleFinder.of(),
538 roots);
539
540 // module name -> reference
541 Map<String, ModuleReference> map = new HashMap<>();
542 cf.modules().forEach(m -> {
543 ModuleReference mref = m.reference();
544 map.put(mref.descriptor().name(), mref);
545 });
546
547 // add the other modules
548 otherMods.stream()
549 .map(finder::find)
550 .flatMap(Optional::stream)
551 .forEach(mref -> map.putIfAbsent(mref.descriptor().name(), mref));
552
553 // set of modules that are observable
554 Set<ModuleReference> mrefs = new HashSet<>(map.values());
555
556 return new ModuleFinder() {
557 @Override
558 public Optional<ModuleReference> find(String name) {
559 return Optional.ofNullable(map.get(name));
560 }
561
562 @Override
563 public Set<ModuleReference> findAll() {
564 return mrefs;
565 }
566 };
567 }
568
569 /*
570 * Returns a map of each service type to the modules that use it
571 * It will include services that are provided by a module but may not used
572 * by any of the observable modules.
573 */
574 private static Map<String, Set<String>> uses(Set<ModuleReference> modules) {
575 // collects the services used by the modules and print uses
576 Map<String, Set<String>> services = new HashMap<>();
577 modules.stream()
578 .map(ModuleReference::descriptor)
579 .forEach(md -> {
580 // include services that may not be used by any observable modules
581 md.provides().forEach(p ->
582 services.computeIfAbsent(p.service(), _k -> new HashSet<>()));
583 md.uses().forEach(s -> services.computeIfAbsent(s, _k -> new HashSet<>())
584 .add(md.name()));
585 });
586 return services;
587 }
588
589 private static void printProviders(PrintWriter log,
590 String header,
591 Set<ModuleReference> modules) {
592 printProviders(log, header, modules, uses(modules));
593 }
594
595 /*
596 * Prints the providers that are used by the specified services.
597 *
598 * The specified services maps a service type name to the modules
599 * using the service type which may be empty if no observable module uses
600 * that service.
601 */
602 private static void printProviders(PrintWriter log,
603 String header,
604 Set<ModuleReference> modules,
605 Map<String, Set<String>> serviceToUses) {
606 if (modules.isEmpty())
607 return;
608
609 // Build a map of a service type to the provider modules
610 Map<String, Set<ModuleDescriptor>> providers = new HashMap<>();
611 modules.stream()
612 .map(ModuleReference::descriptor)
613 .forEach(md -> {
614 md.provides().stream()
615 .filter(p -> serviceToUses.containsKey(p.service()))
616 .forEach(p -> providers.computeIfAbsent(p.service(), _k -> new HashSet<>())
617 .add(md));
618 });
619
620 if (!providers.isEmpty()) {
621 log.println(header);
622 }
623
624 // print the providers of the service types used by the specified modules
625 // sorted by the service type name and then provider's module name
626 providers.entrySet().stream()
627 .sorted(Map.Entry.comparingByKey())
628 .forEach(e -> {
629 String service = e.getKey();
630 e.getValue().stream()
631 .sorted(Comparator.comparing(ModuleDescriptor::name))
632 .forEach(md ->
633 md.provides().stream()
634 .filter(p -> p.service().equals(service))
635 .forEach(p -> {
636 String usedBy;
637 if (serviceToUses.get(p.service()).isEmpty()) {
638 usedBy = "not used by any observable module";
639 } else {
640 usedBy = serviceToUses.get(p.service()).stream()
641 .sorted()
642 .collect(Collectors.joining(",", "used by ", ""));
643 }
644 log.format(" %s provides %s %s%n",
645 md.name(), p.service(), usedBy);
646 })
647 );
648 });
649 }
650
651 private void suggestProviders(JlinkConfiguration config, List<String> args)
652 throws BadArgs
653 {
654 if (args.size() > 1) {
655 throw taskHelper.newBadArgs("err.orphan.argument",
656 toString(args.subList(1, args.size())))
657 .showUsage(true);
658 }
659
660 if (options.bindServices) {
661 log.println(taskHelper.getMessage("no.suggested.providers"));
662 return;
663 }
664
665 ModuleFinder finder = config.finder();
666 if (args.isEmpty()) {
667 // print providers used by the observable modules without service binding
668 Set<ModuleReference> mrefs = finder.findAll();
669 // print uses of the modules that would be linked into the image
670 mrefs.stream()
671 .sorted(Comparator.comparing(mref -> mref.descriptor().name()))
672 .forEach(mref -> {
673 ModuleDescriptor md = mref.descriptor();
674 log.format("%s %s%n", md.name(),
675 mref.location().get());
676 md.uses().stream().sorted()
677 .forEach(s -> log.format(" uses %s%n", s));
678 });
679
680 String msg = String.format("%n%s:", taskHelper.getMessage("suggested.providers.header"));
681 printProviders(log, msg, mrefs, uses(mrefs));
682
683 } else {
684 // comma-separated service types, if specified
685 Set<String> names = Stream.of(args.get(0).split(","))
686 .collect(Collectors.toSet());
687 // find the modules that provide the specified service
688 Set<ModuleReference> mrefs = finder.findAll().stream()
689 .filter(mref -> mref.descriptor().provides().stream()
690 .map(ModuleDescriptor.Provides::service)
691 .anyMatch(names::contains))
692 .collect(Collectors.toSet());
693
694 // find the modules that uses the specified services
695 Map<String, Set<String>> uses = new HashMap<>();
696 names.forEach(s -> uses.computeIfAbsent(s, _k -> new HashSet<>()));
697 finder.findAll().stream()
698 .map(ModuleReference::descriptor)
699 .forEach(md -> md.uses().stream()
700 .filter(names::contains)
701 .forEach(s -> uses.get(s).add(md.name())));
702
703 // check if any name given on the command line are not provided by any module
704 mrefs.stream()
705 .flatMap(mref -> mref.descriptor().provides().stream()
706 .map(ModuleDescriptor.Provides::service))
707 .forEach(names::remove);
708 if (!names.isEmpty()) {
709 log.println(taskHelper.getMessage("warn.provider.notfound",
710 toString(names)));
711 }
712
713 String msg = String.format("%n%s:", taskHelper.getMessage("suggested.providers.header"));
714 printProviders(log, msg, mrefs, uses);
715 }
716 }
717
718 private static String toString(Collection<String> collection) {
719 return collection.stream().sorted()
720 .collect(Collectors.joining(","));
721 }
722
723 private String getSaveOpts() {
724 StringBuilder sb = new StringBuilder();
725 sb.append('#').append(new Date()).append("\n");
726 for (String c : optionsHelper.getInputCommand()) {
727 sb.append(c).append(" ");
728 }
729
730 return sb.toString();
731 }
732
733 private static String getBomHeader() {
734 StringBuilder sb = new StringBuilder();
735 sb.append("#").append(new Date()).append("\n");
736 sb.append("#Please DO NOT Modify this file").append("\n");
737 return sb.toString();
738 }
739
740 private String genBOMContent() throws IOException {
741 StringBuilder sb = new StringBuilder();
742 sb.append(getBomHeader());
743 StringBuilder command = new StringBuilder();
744 for (String c : optionsHelper.getInputCommand()) {
745 command.append(c).append(" ");
746 }
747 sb.append("command").append(" = ").append(command);
748 sb.append("\n");
749
750 return sb.toString();
751 }
752
753 private static String genBOMContent(JlinkConfiguration config,
754 PluginsConfiguration plugins)
755 throws IOException {
756 StringBuilder sb = new StringBuilder();
757 sb.append(getBomHeader());
758 sb.append(config);
759 sb.append(plugins);
760 return sb.toString();
761 }
762
763 private static class ImageHelper implements ImageProvider {
764 final ByteOrder order;
765 final Path packagedModulesPath;
766 final boolean ignoreSigning;
767 final Runtime.Version version;
768 final Set<Archive> archives;
769
770 ImageHelper(Configuration cf,
771 Map<String, Path> modsPaths,
772 ByteOrder order,
773 Path packagedModulesPath,
774 boolean ignoreSigning) throws IOException {
775 this.order = order;
776 this.packagedModulesPath = packagedModulesPath;
777 this.ignoreSigning = ignoreSigning;
778
779 // use the version of java.base module, if present, as
780 // the release version for multi-release JAR files
781 this.version = cf.findModule("java.base")
782 .map(ResolvedModule::reference)
783 .map(ModuleReference::descriptor)
784 .flatMap(ModuleDescriptor::version)
785 .map(ModuleDescriptor.Version::toString)
786 .map(Runtime.Version::parse)
787 .orElse(Runtime.version());
788
789 this.archives = modsPaths.entrySet().stream()
790 .map(e -> newArchive(e.getKey(), e.getValue()))
791 .collect(Collectors.toSet());
792 }
793
794 private Archive newArchive(String module, Path path) {
795 if (path.toString().endsWith(".jmod")) {
796 return new JmodArchive(module, path);
797 } else if (path.toString().endsWith(".jar")) {
798 ModularJarArchive modularJarArchive = new ModularJarArchive(module, path, version);
799
800 Stream<Archive.Entry> signatures = modularJarArchive.entries().filter((entry) -> {
801 String name = entry.name().toUpperCase(Locale.ENGLISH);
802
803 return name.startsWith("META-INF/") && name.indexOf('/', 9) == -1 && (
804 name.endsWith(".SF") ||
805 name.endsWith(".DSA") ||
806 name.endsWith(".RSA") ||
807 name.endsWith(".EC") ||
808 name.startsWith("META-INF/SIG-")
809 );
810 });
811
812 if (signatures.count() != 0) {
813 if (ignoreSigning) {
814 System.err.println(taskHelper.getMessage("warn.signing", path));
815 } else {
816 throw new IllegalArgumentException(taskHelper.getMessage("err.signing", path));
817 }
818 }
819
820 return modularJarArchive;
821 } else if (Files.isDirectory(path)) {
822 return new DirArchive(path);
823 } else {
824 throw new IllegalArgumentException(
825 taskHelper.getMessage("err.not.modular.format", module, path));
826 }
827 }
828
829 @Override
830 public ExecutableImage retrieve(ImagePluginStack stack) throws IOException {
831 ExecutableImage image = ImageFileCreator.create(archives, order, stack);
832 if (packagedModulesPath != null) {
833 // copy the packaged modules to the given path
834 Files.createDirectories(packagedModulesPath);
835 for (Archive a : archives) {
836 Path file = a.getPath();
837 Path dest = packagedModulesPath.resolve(file.getFileName());
838 Files.copy(file, dest);
839 }
840 }
841 return image;
842 }
843 }
844 }