1 /*
2 * Copyright (c) 2014, 2019, 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
26 package jdk.incubator.jpackage.internal;
27
28 import java.io.File;
29 import java.io.IOException;
30 import java.lang.module.ModuleDescriptor;
31 import java.lang.module.ModuleDescriptor.Version;
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.Date;
40 import java.util.LinkedHashSet;
41 import java.util.List;
42 import java.util.Map;
43 import java.util.Optional;
44 import java.util.ResourceBundle;
45 import java.util.Set;
46 import java.util.HashSet;
47 import java.util.function.BiFunction;
48 import java.util.function.Function;
49 import java.util.jar.Attributes;
50 import java.util.jar.JarFile;
51 import java.util.jar.Manifest;
52 import java.util.stream.Collectors;
53 import java.util.stream.Stream;
54
55 /**
56 * StandardBundlerParam
57 *
58 * A parameter to a bundler.
59 *
60 * Also contains static definitions of all of the common bundler parameters.
61 * (additional platform specific and mode specific bundler parameters
62 * are defined in each of the specific bundlers)
63 *
64 * Also contains static methods that operate on maps of parameters.
65 */
66 class StandardBundlerParam<T> extends BundlerParamInfo<T> {
67
68 private static final ResourceBundle I18N = ResourceBundle.getBundle(
69 "jdk.incubator.jpackage.internal.resources.MainResources");
70 private static final String JAVABASEJMOD = "java.base.jmod";
71 private final static String DEFAULT_VERSION = "1.0";
72 private final static String DEFAULT_RELEASE = "1";
73
74 StandardBundlerParam(String id, Class<T> valueType,
75 Function<Map<String, ? super Object>, T> defaultValueFunction,
76 BiFunction<String, Map<String, ? super Object>, T> stringConverter)
77 {
78 this.id = id;
79 this.valueType = valueType;
80 this.defaultValueFunction = defaultValueFunction;
81 this.stringConverter = stringConverter;
82 }
83
84 static final StandardBundlerParam<RelativeFileSet> APP_RESOURCES =
85 new StandardBundlerParam<>(
86 BundleParams.PARAM_APP_RESOURCES,
87 RelativeFileSet.class,
88 null, // no default. Required parameter
89 null // no string translation,
90 // tool must provide complex type
91 );
92
93 @SuppressWarnings("unchecked")
94 static final
95 StandardBundlerParam<List<RelativeFileSet>> APP_RESOURCES_LIST =
96 new StandardBundlerParam<>(
97 BundleParams.PARAM_APP_RESOURCES + "List",
98 (Class<List<RelativeFileSet>>) (Object) List.class,
99 // Default is appResources, as a single item list
100 p -> new ArrayList<>(Collections.singletonList(
101 APP_RESOURCES.fetchFrom(p))),
102 StandardBundlerParam::createAppResourcesListFromString
103 );
104
105 static final StandardBundlerParam<String> SOURCE_DIR =
106 new StandardBundlerParam<>(
107 Arguments.CLIOptions.INPUT.getId(),
108 String.class,
109 p -> null,
110 (s, p) -> {
111 String value = String.valueOf(s);
112 if (value.charAt(value.length() - 1) ==
113 File.separatorChar) {
114 return value.substring(0, value.length() - 1);
115 }
116 else {
117 return value;
118 }
119 }
120 );
121
122 // note that each bundler is likely to replace this one with
123 // their own converter
124 static final StandardBundlerParam<RelativeFileSet> MAIN_JAR =
125 new StandardBundlerParam<>(
126 Arguments.CLIOptions.MAIN_JAR.getId(),
127 RelativeFileSet.class,
128 params -> {
129 extractMainClassInfoFromAppResources(params);
130 return (RelativeFileSet) params.get("mainJar");
131 },
132 (s, p) -> getMainJar(s, p)
133 );
134
135 static final StandardBundlerParam<String> CLASSPATH =
136 new StandardBundlerParam<>(
137 "classpath",
138 String.class,
139 params -> {
140 extractMainClassInfoFromAppResources(params);
141 String cp = (String) params.get("classpath");
142 return cp == null ? "" : cp;
143 },
144 (s, p) -> s
145 );
146
147 static final StandardBundlerParam<String> MAIN_CLASS =
148 new StandardBundlerParam<>(
149 Arguments.CLIOptions.APPCLASS.getId(),
150 String.class,
151 params -> {
152 if (isRuntimeInstaller(params)) {
153 return null;
154 }
155 extractMainClassInfoFromAppResources(params);
156 String s = (String) params.get(
157 BundleParams.PARAM_APPLICATION_CLASS);
158 if (s == null) {
159 s = JLinkBundlerHelper.getMainClassFromModule(
160 params);
161 }
162 return s;
163 },
164 (s, p) -> s
165 );
166
167 static final StandardBundlerParam<File> PREDEFINED_RUNTIME_IMAGE =
168 new StandardBundlerParam<>(
169 Arguments.CLIOptions.PREDEFINED_RUNTIME_IMAGE.getId(),
170 File.class,
171 params -> null,
172 (s, p) -> new File(s)
173 );
174
175 static final StandardBundlerParam<String> APP_NAME =
176 new StandardBundlerParam<>(
177 Arguments.CLIOptions.NAME.getId(),
178 String.class,
179 params -> {
180 String s = MAIN_CLASS.fetchFrom(params);
181 if (s != null) {
182 int idx = s.lastIndexOf(".");
183 if (idx >= 0) {
184 return s.substring(idx+1);
185 }
186 return s;
187 } else if (isRuntimeInstaller(params)) {
188 File f = PREDEFINED_RUNTIME_IMAGE.fetchFrom(params);
189 if (f != null) {
190 return f.getName();
191 }
192 }
193 return null;
194 },
195 (s, p) -> s
196 );
197
198 static final StandardBundlerParam<File> ICON =
199 new StandardBundlerParam<>(
200 Arguments.CLIOptions.ICON.getId(),
201 File.class,
202 params -> null,
203 (s, p) -> new File(s)
204 );
205
206 static final StandardBundlerParam<String> VENDOR =
207 new StandardBundlerParam<>(
208 Arguments.CLIOptions.VENDOR.getId(),
209 String.class,
210 params -> I18N.getString("param.vendor.default"),
211 (s, p) -> s
212 );
213
214 static final StandardBundlerParam<String> DESCRIPTION =
215 new StandardBundlerParam<>(
216 Arguments.CLIOptions.DESCRIPTION.getId(),
217 String.class,
218 params -> params.containsKey(APP_NAME.getID())
219 ? APP_NAME.fetchFrom(params)
220 : I18N.getString("param.description.default"),
221 (s, p) -> s
222 );
223
224 static final StandardBundlerParam<String> COPYRIGHT =
225 new StandardBundlerParam<>(
226 Arguments.CLIOptions.COPYRIGHT.getId(),
227 String.class,
228 params -> MessageFormat.format(I18N.getString(
229 "param.copyright.default"), new Date()),
230 (s, p) -> s
231 );
232
233 @SuppressWarnings("unchecked")
234 static final StandardBundlerParam<List<String>> ARGUMENTS =
235 new StandardBundlerParam<>(
236 Arguments.CLIOptions.ARGUMENTS.getId(),
237 (Class<List<String>>) (Object) List.class,
238 params -> Collections.emptyList(),
239 (s, p) -> null
240 );
241
242 @SuppressWarnings("unchecked")
243 static final StandardBundlerParam<List<String>> JAVA_OPTIONS =
244 new StandardBundlerParam<>(
245 Arguments.CLIOptions.JAVA_OPTIONS.getId(),
246 (Class<List<String>>) (Object) List.class,
247 params -> Collections.emptyList(),
248 (s, p) -> Arrays.asList(s.split("\n\n"))
249 );
250
251 // note that each bundler is likely to replace this one with
252 // their own converter
253 static final StandardBundlerParam<String> VERSION =
254 new StandardBundlerParam<>(
255 Arguments.CLIOptions.VERSION.getId(),
256 String.class,
257 params -> getDefaultAppVersion(params),
258 (s, p) -> s
259 );
260
261 static final StandardBundlerParam<String> RELEASE =
262 new StandardBundlerParam<>(
263 Arguments.CLIOptions.RELEASE.getId(),
264 String.class,
265 params -> DEFAULT_RELEASE,
266 (s, p) -> s
267 );
268
269 @SuppressWarnings("unchecked")
270 public static final StandardBundlerParam<String> LICENSE_FILE =
271 new StandardBundlerParam<>(
272 Arguments.CLIOptions.LICENSE_FILE.getId(),
273 String.class,
274 params -> null,
275 (s, p) -> s
276 );
277
278 static final StandardBundlerParam<File> TEMP_ROOT =
279 new StandardBundlerParam<>(
280 Arguments.CLIOptions.TEMP_ROOT.getId(),
281 File.class,
282 params -> {
283 try {
284 return Files.createTempDirectory(
285 "jdk.incubator.jpackage").toFile();
286 } catch (IOException ioe) {
287 return null;
288 }
289 },
290 (s, p) -> new File(s)
291 );
292
293 public static final StandardBundlerParam<File> CONFIG_ROOT =
294 new StandardBundlerParam<>(
295 "configRoot",
296 File.class,
297 params -> {
298 File root =
299 new File(TEMP_ROOT.fetchFrom(params), "config");
300 root.mkdirs();
301 return root;
302 },
303 (s, p) -> null
304 );
305
306 static final StandardBundlerParam<String> IDENTIFIER =
307 new StandardBundlerParam<>(
308 "identifier.default",
309 String.class,
310 params -> {
311 String s = MAIN_CLASS.fetchFrom(params);
312 if (s == null) return null;
313
314 int idx = s.lastIndexOf(".");
315 if (idx >= 1) {
316 return s.substring(0, idx);
317 }
318 return s;
319 },
320 (s, p) -> s
321 );
322
323 static final StandardBundlerParam<Boolean> BIND_SERVICES =
324 new StandardBundlerParam<>(
325 Arguments.CLIOptions.BIND_SERVICES.getId(),
326 Boolean.class,
327 params -> false,
328 (s, p) -> (s == null || "null".equalsIgnoreCase(s)) ?
329 true : Boolean.valueOf(s)
330 );
331
332
333 static final StandardBundlerParam<Boolean> VERBOSE =
334 new StandardBundlerParam<>(
335 Arguments.CLIOptions.VERBOSE.getId(),
336 Boolean.class,
337 params -> false,
338 // valueOf(null) is false, and we actually do want null
339 (s, p) -> (s == null || "null".equalsIgnoreCase(s)) ?
340 true : Boolean.valueOf(s)
341 );
342
343 static final StandardBundlerParam<File> RESOURCE_DIR =
344 new StandardBundlerParam<>(
345 Arguments.CLIOptions.RESOURCE_DIR.getId(),
346 File.class,
347 params -> null,
348 (s, p) -> new File(s)
349 );
350
351 static final BundlerParamInfo<String> INSTALL_DIR =
352 new StandardBundlerParam<>(
353 Arguments.CLIOptions.INSTALL_DIR.getId(),
354 String.class,
355 params -> null,
356 (s, p) -> s
357 );
358
359 static final StandardBundlerParam<File> PREDEFINED_APP_IMAGE =
360 new StandardBundlerParam<>(
361 Arguments.CLIOptions.PREDEFINED_APP_IMAGE.getId(),
362 File.class,
363 params -> null,
364 (s, p) -> new File(s));
365
366 @SuppressWarnings("unchecked")
367 static final StandardBundlerParam<List<Map<String, ? super Object>>> ADD_LAUNCHERS =
368 new StandardBundlerParam<>(
369 Arguments.CLIOptions.ADD_LAUNCHER.getId(),
370 (Class<List<Map<String, ? super Object>>>) (Object)
371 List.class,
372 params -> new ArrayList<>(1),
373 // valueOf(null) is false, and we actually do want null
374 (s, p) -> null
375 );
376
377 @SuppressWarnings("unchecked")
378 static final StandardBundlerParam
379 <List<Map<String, ? super Object>>> FILE_ASSOCIATIONS =
380 new StandardBundlerParam<>(
381 Arguments.CLIOptions.FILE_ASSOCIATIONS.getId(),
382 (Class<List<Map<String, ? super Object>>>) (Object)
383 List.class,
384 params -> new ArrayList<>(1),
385 // valueOf(null) is false, and we actually do want null
386 (s, p) -> null
387 );
388
389 @SuppressWarnings("unchecked")
390 static final StandardBundlerParam<List<String>> FA_EXTENSIONS =
391 new StandardBundlerParam<>(
392 "fileAssociation.extension",
393 (Class<List<String>>) (Object) List.class,
394 params -> null, // null means not matched to an extension
395 (s, p) -> Arrays.asList(s.split("(,|\\s)+"))
396 );
397
398 @SuppressWarnings("unchecked")
399 static final StandardBundlerParam<List<String>> FA_CONTENT_TYPE =
400 new StandardBundlerParam<>(
401 "fileAssociation.contentType",
402 (Class<List<String>>) (Object) List.class,
403 params -> null,
404 // null means not matched to a content/mime type
405 (s, p) -> Arrays.asList(s.split("(,|\\s)+"))
406 );
407
408 static final StandardBundlerParam<String> FA_DESCRIPTION =
409 new StandardBundlerParam<>(
410 "fileAssociation.description",
411 String.class,
412 params -> APP_NAME.fetchFrom(params) + " File",
413 null
414 );
415
416 static final StandardBundlerParam<File> FA_ICON =
417 new StandardBundlerParam<>(
418 "fileAssociation.icon",
419 File.class,
420 ICON::fetchFrom,
421 (s, p) -> new File(s)
422 );
423
424 @SuppressWarnings("unchecked")
425 static final BundlerParamInfo<List<Path>> MODULE_PATH =
426 new StandardBundlerParam<>(
427 Arguments.CLIOptions.MODULE_PATH.getId(),
428 (Class<List<Path>>) (Object)List.class,
429 p -> { return getDefaultModulePath(); },
430 (s, p) -> {
431 List<Path> modulePath = Arrays.asList(s
432 .split(File.pathSeparator)).stream()
433 .map(ss -> new File(ss).toPath())
434 .collect(Collectors.toList());
435 Path javaBasePath = null;
436 if (modulePath != null) {
437 javaBasePath = JLinkBundlerHelper
438 .findPathOfModule(modulePath, JAVABASEJMOD);
439 } else {
440 modulePath = new ArrayList<Path>();
441 }
442
443 // Add the default JDK module path to the module path.
444 if (javaBasePath == null) {
445 List<Path> jdkModulePath = getDefaultModulePath();
446
447 if (jdkModulePath != null) {
448 modulePath.addAll(jdkModulePath);
449 javaBasePath =
450 JLinkBundlerHelper.findPathOfModule(
451 modulePath, JAVABASEJMOD);
452 }
453 }
454
455 if (javaBasePath == null ||
456 !Files.exists(javaBasePath)) {
457 Log.error(String.format(I18N.getString(
458 "warning.no.jdk.modules.found")));
459 }
460
461 return modulePath;
462 });
463
464 static final BundlerParamInfo<String> MODULE =
465 new StandardBundlerParam<>(
466 Arguments.CLIOptions.MODULE.getId(),
467 String.class,
468 p -> null,
469 (s, p) -> {
470 return String.valueOf(s);
471 });
472
473 @SuppressWarnings("unchecked")
474 static final BundlerParamInfo<Set<String>> ADD_MODULES =
475 new StandardBundlerParam<>(
476 Arguments.CLIOptions.ADD_MODULES.getId(),
477 (Class<Set<String>>) (Object) Set.class,
478 p -> new LinkedHashSet<String>(),
479 (s, p) -> new LinkedHashSet<>(Arrays.asList(s.split(",")))
480 );
481
482 @SuppressWarnings("unchecked")
483 static final BundlerParamInfo<Set<String>> LIMIT_MODULES =
484 new StandardBundlerParam<>(
485 "limit-modules",
486 (Class<Set<String>>) (Object) Set.class,
487 p -> new LinkedHashSet<String>(),
488 (s, p) -> new LinkedHashSet<>(Arrays.asList(s.split(",")))
489 );
490
491 static boolean isRuntimeInstaller(Map<String, ? super Object> params) {
492 if (params.containsKey(MODULE.getID()) ||
493 params.containsKey(MAIN_JAR.getID()) ||
494 params.containsKey(PREDEFINED_APP_IMAGE.getID())) {
495 return false; // we are building or are given an application
496 }
497 // runtime installer requires --runtime-image, if this is false
498 // here then we should have thrown error validating args.
499 return params.containsKey(PREDEFINED_RUNTIME_IMAGE.getID());
500 }
501
502 static File getPredefinedAppImage(Map<String, ? super Object> params) {
503 File applicationImage = null;
504 if (PREDEFINED_APP_IMAGE.fetchFrom(params) != null) {
505 applicationImage = PREDEFINED_APP_IMAGE.fetchFrom(params);
506 if (!applicationImage.exists()) {
507 throw new RuntimeException(
508 MessageFormat.format(I18N.getString(
509 "message.app-image-dir-does-not-exist"),
510 PREDEFINED_APP_IMAGE.getID(),
511 applicationImage.toString()));
512 }
513 }
514 return applicationImage;
515 }
516
517 static File getPredefinedRuntime(Map<String, ? super Object> params)
518 throws PackagerException {
519 File runtime = PREDEFINED_RUNTIME_IMAGE.fetchFrom(params);
520 if (runtime != null && !runtime.exists()) {
521 throw new PackagerException (
522 "message.runtime-image-dir-does-not-exist",
523 PREDEFINED_RUNTIME_IMAGE.getID(),
524 runtime.toString());
525 }
526 return runtime;
527 }
528
529 static void copyPredefinedRuntimeImage(
530 Map<String, ? super Object> params,
531 AbstractAppImageBuilder appBuilder)
532 throws IOException , ConfigException {
533 File topImage = PREDEFINED_RUNTIME_IMAGE.fetchFrom(params);
534 if (!topImage.exists()) {
535 throw new ConfigException(
536 MessageFormat.format(I18N.getString(
537 "message.runtime-image-dir-does-not-exist"),
538 PREDEFINED_RUNTIME_IMAGE.getID(),
539 topImage.toString()),
540 MessageFormat.format(I18N.getString(
541 "message.runtime-image-dir-does-not-exist.advice"),
542 PREDEFINED_RUNTIME_IMAGE.getID()));
543 }
544 File image = appBuilder.getRuntimeImageDir(topImage);
545 // copy whole runtime, need to skip jmods and src.zip
546 final List<String> excludes = Arrays.asList("jmods", "src.zip");
547 IOUtils.copyRecursive(image.toPath(), appBuilder.getRuntimeRoot(), excludes);
548
549 // if module-path given - copy modules to appDir/mods
550 List<Path> modulePath =
551 StandardBundlerParam.MODULE_PATH.fetchFrom(params);
552 List<Path> defaultModulePath = getDefaultModulePath();
553 Path dest = appBuilder.getAppModsDir();
554
555 if (dest != null) {
556 for (Path mp : modulePath) {
557 if (!defaultModulePath.contains(mp)) {
558 Files.createDirectories(dest);
559 IOUtils.copyRecursive(mp, dest);
560 }
561 }
562 }
563
564 appBuilder.prepareApplicationFiles(params);
565 }
566
567 static void extractMainClassInfoFromAppResources(
568 Map<String, ? super Object> params) {
569 boolean hasMainClass = params.containsKey(MAIN_CLASS.getID());
570 boolean hasMainJar = params.containsKey(MAIN_JAR.getID());
571 boolean hasMainJarClassPath = params.containsKey(CLASSPATH.getID());
572 boolean hasModule = params.containsKey(MODULE.getID());
573
574 if (hasMainClass && hasMainJar && hasMainJarClassPath || hasModule ||
575 isRuntimeInstaller(params)) {
576 return;
577 }
578
579 // it's a pair.
580 // The [0] is the srcdir [1] is the file relative to sourcedir
581 List<String[]> filesToCheck = new ArrayList<>();
582
583 if (hasMainJar) {
584 RelativeFileSet rfs = MAIN_JAR.fetchFrom(params);
585 for (String s : rfs.getIncludedFiles()) {
586 filesToCheck.add(
587 new String[] {rfs.getBaseDirectory().toString(), s});
588 }
589 } else if (hasMainJarClassPath) {
590 for (String s : CLASSPATH.fetchFrom(params).split("\\s+")) {
591 if (APP_RESOURCES.fetchFrom(params) != null) {
592 filesToCheck.add(
593 new String[] {APP_RESOURCES.fetchFrom(params)
594 .getBaseDirectory().toString(), s});
595 }
596 }
597 } else {
598 List<RelativeFileSet> rfsl = APP_RESOURCES_LIST.fetchFrom(params);
599 if (rfsl == null || rfsl.isEmpty()) {
600 return;
601 }
602 for (RelativeFileSet rfs : rfsl) {
603 if (rfs == null) continue;
604
605 for (String s : rfs.getIncludedFiles()) {
606 filesToCheck.add(
607 new String[]{rfs.getBaseDirectory().toString(), s});
608 }
609 }
610 }
611
612 // presume the set iterates in-order
613 for (String[] fnames : filesToCheck) {
614 try {
615 // only sniff jars
616 if (!fnames[1].toLowerCase().endsWith(".jar")) continue;
617
618 File file = new File(fnames[0], fnames[1]);
619 // that actually exist
620 if (!file.exists()) continue;
621
622 try (JarFile jf = new JarFile(file)) {
623 Manifest m = jf.getManifest();
624 Attributes attrs = (m != null) ?
625 m.getMainAttributes() : null;
626
627 if (attrs != null) {
628 if (!hasMainJar) {
629 if (fnames[0] == null) {
630 fnames[0] = file.getParentFile().toString();
631 }
632 params.put(MAIN_JAR.getID(), new RelativeFileSet(
633 new File(fnames[0]),
634 new LinkedHashSet<>(Collections
635 .singletonList(file))));
636 }
637 if (!hasMainJarClassPath) {
638 String cp =
639 attrs.getValue(Attributes.Name.CLASS_PATH);
640 params.put(CLASSPATH.getID(),
641 cp == null ? "" : cp);
642 }
643 break;
644 }
645 }
646 } catch (IOException ignore) {
647 ignore.printStackTrace();
648 }
649 }
650 }
651
652 static void validateMainClassInfoFromAppResources(
653 Map<String, ? super Object> params) throws ConfigException {
654 boolean hasMainClass = params.containsKey(MAIN_CLASS.getID());
655 boolean hasMainJar = params.containsKey(MAIN_JAR.getID());
656 boolean hasMainJarClassPath = params.containsKey(CLASSPATH.getID());
657 boolean hasModule = params.containsKey(MODULE.getID());
658 boolean hasAppImage = params.containsKey(PREDEFINED_APP_IMAGE.getID());
659
660 if (hasMainClass && hasMainJar && hasMainJarClassPath ||
661 hasAppImage || isRuntimeInstaller(params)) {
662 return;
663 }
664 if (hasModule) {
665 if (JLinkBundlerHelper.getMainClassFromModule(params) == null) {
666 throw new ConfigException(
667 I18N.getString("ERR_NoMainClass"), null);
668 }
669 } else {
670 extractMainClassInfoFromAppResources(params);
671
672 if (!params.containsKey(MAIN_CLASS.getID())) {
673 if (hasMainJar) {
674 throw new ConfigException(
675 MessageFormat.format(I18N.getString(
676 "error.no-main-class-with-main-jar"),
677 MAIN_JAR.fetchFrom(params)),
678 MessageFormat.format(I18N.getString(
679 "error.no-main-class-with-main-jar.advice"),
680 MAIN_JAR.fetchFrom(params)));
681 } else {
682 throw new ConfigException(
683 I18N.getString("error.no-main-class"),
684 I18N.getString("error.no-main-class.advice"));
685 }
686 }
687 }
688 }
689
690 private static List<RelativeFileSet>
691 createAppResourcesListFromString(String s,
692 Map<String, ? super Object> objectObjectMap) {
693 List<RelativeFileSet> result = new ArrayList<>();
694 for (String path : s.split("[:;]")) {
695 File f = new File(path);
696 if (f.getName().equals("*") || path.endsWith("/") ||
697 path.endsWith("\\")) {
698 if (f.getName().equals("*")) {
699 f = f.getParentFile();
700 }
701 Set<File> theFiles = new HashSet<>();
702 try {
703 try (Stream<Path> stream = Files.walk(f.toPath())) {
704 stream.filter(Files::isRegularFile)
705 .forEach(p -> theFiles.add(p.toFile()));
706 }
707 } catch (IOException e) {
708 e.printStackTrace();
709 }
710 result.add(new RelativeFileSet(f, theFiles));
711 } else {
712 result.add(new RelativeFileSet(f.getParentFile(),
713 Collections.singleton(f)));
714 }
715 }
716 return result;
717 }
718
719 private static RelativeFileSet getMainJar(
720 String mainJarValue, Map<String, ? super Object> params) {
721 for (RelativeFileSet rfs : APP_RESOURCES_LIST.fetchFrom(params)) {
722 File appResourcesRoot = rfs.getBaseDirectory();
723 File mainJarFile = new File(appResourcesRoot, mainJarValue);
724
725 if (mainJarFile.exists()) {
726 return new RelativeFileSet(appResourcesRoot,
727 new LinkedHashSet<>(Collections.singletonList(
728 mainJarFile)));
729 }
730 mainJarFile = new File(mainJarValue);
731 if (mainJarFile.exists()) {
732 // absolute path for main-jar may fail is not legal
733 // below contains explicit error message.
734 } else {
735 List<Path> modulePath = MODULE_PATH.fetchFrom(params);
736 modulePath.removeAll(getDefaultModulePath());
737 if (!modulePath.isEmpty()) {
738 Path modularJarPath = JLinkBundlerHelper.findPathOfModule(
739 modulePath, mainJarValue);
740 if (modularJarPath != null &&
741 Files.exists(modularJarPath)) {
742 return new RelativeFileSet(appResourcesRoot,
743 new LinkedHashSet<>(Collections.singletonList(
744 modularJarPath.toFile())));
745 }
746 }
747 }
748 }
749
750 throw new IllegalArgumentException(
751 new ConfigException(MessageFormat.format(I18N.getString(
752 "error.main-jar-does-not-exist"),
753 mainJarValue), I18N.getString(
754 "error.main-jar-does-not-exist.advice")));
755 }
756
757 static List<Path> getDefaultModulePath() {
758 List<Path> result = new ArrayList<Path>();
759 Path jdkModulePath = Paths.get(
760 System.getProperty("java.home"), "jmods").toAbsolutePath();
761
762 if (jdkModulePath != null && Files.exists(jdkModulePath)) {
763 result.add(jdkModulePath);
764 }
765 else {
766 // On a developer build the JDK Home isn't where we expect it
767 // relative to the jmods directory. Do some extra
768 // processing to find it.
769 Map<String, String> env = System.getenv();
770
771 if (env.containsKey("JDK_HOME")) {
772 jdkModulePath = Paths.get(env.get("JDK_HOME"),
773 ".." + File.separator + "images"
774 + File.separator + "jmods").toAbsolutePath();
775
776 if (jdkModulePath != null && Files.exists(jdkModulePath)) {
777 result.add(jdkModulePath);
778 }
779 }
780 }
781
782 return result;
783 }
784
785 static String getDefaultAppVersion(Map<String, ? super Object> params) {
786 String appVersion = DEFAULT_VERSION;
787
788 ModuleDescriptor descriptor = JLinkBundlerHelper.getMainModuleDescription(params);
789 if (descriptor != null) {
790 Optional<Version> oversion = descriptor.version();
791 if (oversion.isPresent()) {
792 Log.verbose(MessageFormat.format(I18N.getString(
793 "message.module-version"),
794 oversion.get().toString(),
795 JLinkBundlerHelper.getMainModule(params)));
796 appVersion = oversion.get().toString();
797 }
798 }
799
800 return appVersion;
801 }
802 }