1 /*
2 * Copyright (c) 2011, 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
26 package com.sun.javafx.tools.packager;
27
28 import com.oracle.tools.packager.*;
29 import com.oracle.tools.packager.ConfigException;
30 import com.oracle.tools.packager.UnsupportedPlatformException;
31 import com.sun.javafx.tools.packager.bundlers.Bundler.BundleType;
32 import com.oracle.tools.packager.Log;
33
34 import java.io.File;
35 import java.io.FileInputStream;
36 import java.io.IOException;
37 import java.text.MessageFormat;
38 import java.util.*;
39 import java.util.stream.Stream;
40 import java.nio.file.Files;
41 import java.nio.file.Path;
42
43 import jdk.packager.internal.legacy.JLinkBundlerHelper;
44
45 /**
46 * @deprecated use {@link ToolProvider} to locate the {@code "javapackager"} tool instead.
47 */
48 @Deprecated(since="10", forRemoval=true)
49 public class Main {
50
51 private static final ResourceBundle bundle =
52 ResourceBundle.getBundle("com/sun/javafx/tools/packager/Bundle");
53
54 private static final String version = bundle.getString("MSG_Version")
55 + " " + PackagerLib.JAVAFX_VERSION + "\n";
56 private static final String help = bundle.getString("MSG_Help_1")
57 + bundle.getString("MSG_Help_2")
58 + MessageFormat.format(bundle.getString("MSG_Help_3"), File.pathSeparator)
59 + bundle.getString("MSG_Help_4")
60 + bundle.getString("MSG_Help_5")
61 + bundle.getString("MSG_Help_6")
62 + bundle.getString("MSG_Help_7");
63
64 private static String nextArg(String args[], int i) {
65 return (i == args.length - 1) ? "" : args[i + 1];
66 }
67
68 private static boolean verbose = false;
69 private static boolean packageAsJar = false;
70 private static boolean genJNLP = false;
71 private static boolean genPackages = false;
72 private static boolean css2Bin = false;
73 private static boolean signJar = false;
74 private static boolean makeAll = false;
75
76 private static void addResources(CommonParams commonParams,
77 String srcdir, String srcfiles) {
78 if (srcdir == null || "".equals(srcdir)) {
79 return;
80 }
81
82 File baseDir = new File(srcdir);
83
84 if (!baseDir.isDirectory()) {
85 Log.info("Unable to add resources: \"-srcdir\" is not a directory.");
86 return;
87 }
88
89 List<String> fileNames;
90 if (srcfiles != null) {
91 fileNames = Arrays.asList(srcfiles.split(File.pathSeparator));
92 } else {
93 // "-srcfiles" is omitted, all files in srcdir (which
94 // is a mandatory argument in this case) will be packaged.
95 fileNames = new ArrayList<>();
96 try (Stream<Path> files = Files.list(baseDir.toPath())) {
97 files.forEach(file -> fileNames.add(file.getFileName().toString()));
98 } catch (IOException e) {
99 Log.info("Unable to add resources: " + e.getMessage());
100 }
101 }
102
103 fileNames.forEach(file -> commonParams.addResource(baseDir, file));
104 }
105
106 private static void addArgument(DeployParams deployParams, String argument) {
107 if (deployParams.arguments != null) {
108 deployParams.arguments.add(argument);
109 } else {
110 List<String> list = new LinkedList<>();
111 list.add(argument);
112 deployParams.setArguments(list);
113 }
114 }
115
116 private static void addArgument(CreateJarParams deployParams, String argument) {
117 if (deployParams.arguments != null) {
118 deployParams.arguments.add(argument);
119 } else {
120 List<String> list = new LinkedList<>();
121 list.add(argument);
122 deployParams.setArguments(list);
123 }
124 }
125
126 private static Map<String, String> createAttrMap(String arg) {
127 Map<String, String> map = new HashMap<>();
128 if (arg == null || "".equals(arg)) {
129 return null;
130 }
131 String[] pairsArray = arg.split(",");
132 for (String pair: pairsArray) {
133 String[] attr = pair.split("=");
134 map.put(attr[0].trim(), attr[1].trim());
135 }
136 return map;
137 }
138
139 private static List<Param> parseParams(String filename) throws IOException {
140 File paramFile = new File(filename);
141 Properties properties = new Properties();
142 FileInputStream in = new FileInputStream(paramFile);
143 properties.load(in);
144 in.close();
145
146 List<Param> parameters = new ArrayList<>(properties.size());
147
148 for (Map.Entry en : properties.entrySet()) {
149 Param p = new Param();
150 p.setName((String)en.getKey());
151 p.setValue((String)en.getValue());
152 parameters.add(p);
153 }
154 return parameters;
155 }
156
157 private static List<HtmlParam> parseHtmlParams(String filename) throws IOException {
158 File paramFile = new File(filename);
159 Properties properties = new Properties();
160 FileInputStream in = new FileInputStream(paramFile);
161 properties.load(in);
162 in.close();
163
164 List<HtmlParam> parameters = new ArrayList<>(properties.size());
165
166 for (Map.Entry en : properties.entrySet()) {
167 HtmlParam p = new HtmlParam();
168 p.setName((String)en.getKey());
169 p.setValue((String)en.getValue());
170 parameters.add(p);
171 }
172 return parameters;
173 }
174
175 private static List<JSCallback> parseCallbacks(String param) {
176 String[] callbacks = param.split(",");
177 List<JSCallback> list = new ArrayList<>(callbacks.length);
178
179 for (String cb: callbacks) {
180 String[] nameCmd = cb.split(":");
181 if (nameCmd.length == 2) {
182 list.add(new JSCallback(nameCmd[0], nameCmd[1]));
183 }
184 }
185 return list;
186 }
187
188
189 @SuppressWarnings("deprecation")
190 public static void main(String... args) throws Exception {
191 BundleType bundleType = BundleType.NONE;
192
193 if (args.length == 0 || args.length == 1 && args[0].equals("-help")) {
194 System.out.println(help);
195 } else if (args.length == 1 && args[0].equals("-version")) {
196 System.out.println(version);
197 } else {
198 PackagerLib packager = new PackagerLib();
199 CreateJarParams createJarParams = new CreateJarParams();
200 DeployParams deployParams = new DeployParams();
201 CreateBSSParams createBssParams = new CreateBSSParams();
202 SignJarParams signJarParams = new SignJarParams();
203 MakeAllParams makeAllParams = new MakeAllParams();
204 String srcdir = null;
205 String srcfiles = null;
206
207 try {
208 if (args[0].equalsIgnoreCase("-createjar")) {
209 Log.info("Warning: -createjar has been deprecated and will be removed in a future release.");
210 for (int i = 1; i < args.length; i++) {
211 String arg = args[i];
212 if (arg.equalsIgnoreCase("-appclass")) {
213 createJarParams.setApplicationClass(nextArg(args, i++));
214 } else if (arg.equalsIgnoreCase("-preloader")) {
215 createJarParams.setPreloader(nextArg(args, i++));
216 } else if (arg.equalsIgnoreCase("-classpath")) {
217 createJarParams.setClasspath(nextArg(args, i++));
218 } else if (arg.equalsIgnoreCase("-manifestAttrs")) {
219 createJarParams.setManifestAttrs(createAttrMap(nextArg(args, i++)));
220 } else if (arg.equalsIgnoreCase("-noembedlauncher")) {
221 System.err.println("-noembedlauncher is deprecated");
222 } else if (arg.equalsIgnoreCase("-nocss2bin")) {
223 createJarParams.setCss2bin(false);
224 } else if (arg.equalsIgnoreCase("-runtimeVersion")) {
225 createJarParams.setFxVersion(nextArg(args, i++));
226 System.err.println("-runtimeVersion is deprecated");
227 } else if (arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
228 createJarParams.setVerbose(true);
229 verbose = true;
230 } else if (arg.equalsIgnoreCase("-outdir")) {
231 createJarParams.setOutdir(new File(nextArg(args, i++)));
232 } else if (arg.equalsIgnoreCase("-outfile")) {
233 createJarParams.setOutfile(nextArg(args, i++));
234 } else if (arg.equalsIgnoreCase("-" + StandardBundlerParam.SOURCE_DIR.getID())) {
235 srcdir = nextArg(args, i++);
236 } else if (arg.equalsIgnoreCase("-srcfiles")) {
237 srcfiles = nextArg(args, i++);
238 } else if (arg.equalsIgnoreCase("-argument")) {
239 addArgument(createJarParams, nextArg(args, i++));
240 } else if (arg.equalsIgnoreCase("-paramFile")) {
241 createJarParams.setParams(parseParams(nextArg(args, i++)));
242 } else {
243 throw new PackagerException("ERR_UnknownArgument", arg);
244 }
245 }
246
247 addResources(createJarParams, srcdir, srcfiles);
248 packageAsJar = true;
249 } else if (args[0].equalsIgnoreCase("-deploy")) {
250 File templateInFile = null;
251 File templateOutFile = null;
252 deployParams.setBundleType(BundleType.JNLP);
253 deployParams.setTargetFormat("jnlp");
254
255 //can only set it to true with command line, reset default
256 deployParams.setEmbedJNLP(false);
257
258 for (int i = 1; i < args.length; i++) {
259 String arg = args[i];
260 if (arg.startsWith("-B")) {
261 String key;
262 String value;
263
264 int keyStart = 2;
265 int equals = arg.indexOf("=");
266 int len = arg.length();
267 if (equals < keyStart) {
268 if (keyStart < len) {
269 key = arg.substring(keyStart, len);
270 value = Boolean.TRUE.toString();
271 } else {
272 continue;
273 }
274 } else if (keyStart < equals) {
275 key = arg.substring(keyStart, equals);
276 value = arg.substring(equals+1, len);
277 } else {
278 continue;
279 }
280 deployParams.addBundleArgument(key, value);
281 } else if (arg.equalsIgnoreCase("-title")) {
282 deployParams.setTitle(nextArg(args, i++));
283 } else if (arg.equalsIgnoreCase("-vendor")) {
284 deployParams.setVendor(nextArg(args, i++));
285 } else if (arg.equalsIgnoreCase("-native")) {
286 bundleType = BundleType.NATIVE;
287 String format = null; //null means ANY
288 if (i+1 < args.length && !args[i+1].startsWith("-")) {
289 String v = args[++i];
290 com.sun.javafx.tools.packager.bundlers.Bundler.Bundle bundle =
291 com.sun.javafx.tools.packager.bundlers.Bundler.stringToBundle(v);
292 bundleType = bundle.type;
293 format = bundle.format;
294 }
295 deployParams.setBundleType(bundleType);
296 deployParams.setTargetFormat(format);
297 } else if (arg.equalsIgnoreCase("-description")) {
298 deployParams.setDescription(nextArg(args, i++));
299 } else if(arg.equalsIgnoreCase("-appclass")) {
300 deployParams.setApplicationClass(nextArg(args, i++));
301 } else if(arg.equalsIgnoreCase("-daemon")) {
302 deployParams.setServiceHint(true);
303 } else if(arg.equalsIgnoreCase("-singleton")) {
304 deployParams.setSingleton(true);
305 } else if(arg.equalsIgnoreCase("-installdirChooser")) {
306 deployParams.setInstalldirChooser(true);
307 } else if (arg.equalsIgnoreCase("-preloader")) {
308 deployParams.setPreloader(nextArg(args, i++));
309 } else if (arg.equalsIgnoreCase("-paramFile")) {
310 deployParams.setParams(parseParams(nextArg(args, i++)));
311 } else if (arg.equalsIgnoreCase("-htmlParamFile")) {
312 deployParams.setHtmlParams(parseHtmlParams(nextArg(args, i++)));
313 } else if (arg.equalsIgnoreCase("-width")) {
314 deployParams.setWidth(Integer.parseInt(nextArg(args, i++)));
315 } else if (arg.equalsIgnoreCase("-height")) {
316 deployParams.setHeight(Integer.parseInt(nextArg(args, i++)));
317 } else if (arg.equalsIgnoreCase("-name")) {
318 deployParams.setAppName(nextArg(args, i++));
319 } else if (arg.equalsIgnoreCase("-embedJNLP")) {
320 deployParams.setEmbedJNLP(true);
321 } else if (arg.equalsIgnoreCase("-embedCertificates")) {
322 System.err.println("-embedCertificates is deprecated");
323 } else if (arg.equalsIgnoreCase("-allpermissions")) {
324 deployParams.setAllPermissions(true);
325 } else if (arg.equalsIgnoreCase("-updatemode")) {
326 deployParams.setUpdateMode(nextArg(args, i++));
327 } else if (arg.equalsIgnoreCase("-isExtension")) {
328 deployParams.setExtension(true);
329 } else if (arg.equalsIgnoreCase("-callbacks")) {
330 deployParams.setJSCallbacks(parseCallbacks(nextArg(args, i++)));
331 } else if (arg.equalsIgnoreCase("-templateInFilename")) {
332 templateInFile = new File(nextArg(args, i++));
333 } else if (arg.equalsIgnoreCase("-templateOutFilename")) {
334 templateOutFile = new File(nextArg(args, i++));
335 } else if (arg.equalsIgnoreCase("-appId") || arg.equalsIgnoreCase("-templateId")) {
336 String appIdArg = nextArg(args, i++);
337 deployParams.setAppId(appIdArg);
338 deployParams.setId(appIdArg);
339 } else if (arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
340 deployParams.setVerbose(true);
341 verbose = true;
342 } else if (arg.equalsIgnoreCase("-includedt")) {
343 deployParams.setIncludeDT(true);
344 } else if (arg.equalsIgnoreCase("-outdir")) {
345 deployParams.setOutdir(new File(nextArg(args, i++)));
346 } else if (arg.equalsIgnoreCase("-outfile")) {
347 deployParams.setOutfile(nextArg(args, i++));
348 } else if (arg.equalsIgnoreCase("-" + StandardBundlerParam.SOURCE_DIR.getID())) {
349 srcdir = nextArg(args, i++);
350 deployParams.srcdir = srcdir;
351 } else if (arg.equalsIgnoreCase("-srcfiles")) {
352 srcfiles = nextArg(args, i++);
353 } else if (arg.equalsIgnoreCase("-argument")) {
354 addArgument(deployParams, nextArg(args, i++));
355 } else if (arg.equalsIgnoreCase("-nosign")) {
356 deployParams.setSignBundle(false);
357 } else if (arg.equals(ADD_MODULES)) {
358 deployParams.addAddModule(nextArg(args, i++));
359 } else if (arg.startsWith(ADD_MODULES + "=")) {
360 deployParams.addAddModule(arg.replace(ADD_MODULES + "=", ""));
361 } else if (arg.equals(LIMIT_MODULES)) {
362 deployParams.addLimitModule(nextArg(args, i++));
363 } else if (arg.startsWith(LIMIT_MODULES + "=")) {
364 deployParams.addLimitModule(arg.replace(LIMIT_MODULES + "=", ""));
365 } else if (arg.equals(STRIP_NATIVE_COMMANDS)) {
366 deployParams.setStripNativeCommands(Boolean.valueOf(nextArg(args, i++)));
367 } else if (arg.equals(STRIP_NATIVE_COMMANDS + "=")) {
368 deployParams.setStripNativeCommands(Boolean.valueOf(arg.replace(STRIP_NATIVE_COMMANDS + "=", "")));
369 } else if (arg.equals(DETECT_MODULES)) {
370 deployParams.setDetectModules(true);
371 } else if (arg.equals(MODULE_PATH) || arg.equals(P)) {
372 deployParams.modulePath = nextArg(args, i++);
373 } else if (arg.equals(MODULE_PATH + "=")) {
374 deployParams.modulePath = arg.replace(MODULE_PATH + "=", "");
375 } else if (arg.equals(MODULE) || arg.equals(M)) {
376 deployParams.setModule(nextArg(args, i++));
377 } else if (arg.equals(MODULE + "=")) {
378 deployParams.setModule(arg.replace(MODULE + "=", ""));
379 } else if (arg.startsWith(J_XDEBUG)) {
380 deployParams.setDebug(arg.replace(J_XDEBUG, ""));
381 } else {
382 throw new PackagerException("ERR_UnknownArgument", arg);
383 }
384 }
385 if (templateInFile != null) {
386 deployParams.addTemplate(templateInFile, templateOutFile);
387 }
388
389 if (deployParams.validateForJNLP()) {
390 genJNLP = true;
391 }
392
393 if (deployParams.validateForBundle()) {
394 genPackages = true;
395 }
396
397 addResources(deployParams, srcdir, srcfiles);
398 } else if (args[0].equalsIgnoreCase("-createbss")) {
399 Log.info("Warning: -createbss has been deprecated and will be removed in a future release.");
400 for (int i = 1; i < args.length; i++) {
401 String arg = args[i];
402 if (arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
403 createBssParams.setVerbose(true);
404 verbose = true;
405 } else if (arg.equalsIgnoreCase("-outdir")) {
406 createBssParams.setOutdir(new File(nextArg(args, i++)));
407 } else if (arg.equalsIgnoreCase("-srcdir")) {
408 srcdir = nextArg(args, i++);
409 } else if (arg.equalsIgnoreCase("-srcfiles")) {
410 srcfiles = nextArg(args, i++);
411 } else {
412 throw new PackagerException("ERR_UnknownArgument", arg);
413 }
414 }
415
416 addResources(createBssParams, srcdir, srcfiles);
417 css2Bin = true;
418 } else if (args[0].equalsIgnoreCase("-signJar")) {
419 Log.info("Warning: -signJar has been deprecated and will be removed in a future release.");
420 for (int i = 1; i < args.length; i++) {
421 String arg = args[i];
422 if (arg.equalsIgnoreCase("-keyStore")) {
423 signJarParams.setKeyStore(new File(nextArg(args, i++)));
424 } else if(arg.equalsIgnoreCase("-alias")) {
425 signJarParams.setAlias(nextArg(args, i++));
426 } else if(arg.equalsIgnoreCase("-storePass")) {
427 signJarParams.setStorePass(nextArg(args, i++));
428 } else if(arg.equalsIgnoreCase("-keyPass")) {
429 signJarParams.setKeyPass(nextArg(args, i++));
430 } else if(arg.equalsIgnoreCase("-storeType")) {
431 signJarParams.setStoreType(nextArg(args, i++));
432 } else if(arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
433 signJarParams.setVerbose(true);
434 verbose = true;
435 } else if (arg.equalsIgnoreCase("-outdir")) {
436 signJarParams.setOutdir(new File(nextArg(args, i++)));
437 } else if (arg.equalsIgnoreCase("-srcdir")) {
438 srcdir = nextArg(args, i++);
439 } else if (arg.equalsIgnoreCase("-srcfiles")) {
440 srcfiles = nextArg(args, i++);
441 } else {
442 throw new PackagerException("ERR_UnknownArgument", arg);
443 }
444 }
445
446 addResources(signJarParams, srcdir, srcfiles);
447 signJar = true;
448 } else if (args[0].equalsIgnoreCase("-makeall")) {
449 System.err.println("-makeall is deprecated");
450 for (int i = 1; i < args.length; i++) {
451 String arg = args[i];
452 if (arg.equalsIgnoreCase("-appclass")) {
453 makeAllParams.setAppClass(nextArg(args, i++));
454 } else if (arg.equalsIgnoreCase("-preloader")) {
455 makeAllParams.setPreloader(nextArg(args, i++));
456 } else if (arg.equalsIgnoreCase("-classpath")) {
457 makeAllParams.setClasspath(nextArg(args, i++));
458 } else if (arg.equalsIgnoreCase("-name")) {
459 makeAllParams.setAppName(nextArg(args, i++));
460 } else if(arg.equalsIgnoreCase("-width")) {
461 makeAllParams.setWidth(Integer.parseInt(nextArg(args, i++)));
462 } else if(arg.equalsIgnoreCase("-height")) {
463 makeAllParams.setHeight(Integer.parseInt(nextArg(args, i++)));
464 } else if(arg.equalsIgnoreCase("-v")) {
465 makeAllParams.setVerbose(true);
466 } else {
467 throw new PackagerException("ERR_UnknownArgument", arg);
468 }
469 }
470 makeAll = true;
471 } else if (args[0].equalsIgnoreCase("-help")) {
472 showBundlerHelp(args[1], args.length > 2 && "-verbose".equals(args[2]));
473 } else {
474 System.err.println(MessageFormat.format(
475 bundle.getString("ERR_UnknownCommand"),
476 args[0]));
477 System.exit(-1);
478 }
479
480 //set default logger
481 if (verbose) {
482 com.oracle.tools.packager.Log.setLogger(new com.oracle.tools.packager.Log.Logger(true));
483 } else {
484 com.oracle.tools.packager.Log.setLogger(new com.oracle.tools.packager.Log.Logger(false));
485 }
486
487 if (css2Bin) {
488 createBssParams.validate();
489 packager.generateBSS(createBssParams);
490 }
491 if (packageAsJar) {
492 createJarParams.validate();
493 packager.packageAsJar(createJarParams);
494 }
495 if (genJNLP) {
496 deployParams.setBundleType(BundleType.JNLP);
497 deployParams.validate();
498 packager.generateDeploymentPackages(deployParams);
499 }
500 if (genPackages) {
501 deployParams.setBundleType(bundleType);
502 deployParams.validate();
503 packager.generateDeploymentPackages(deployParams);
504 }
505 if (signJar) {
506 signJarParams.validate();
507 if (signJarParams.storePass == null) {
508 char[] passwd = System.console().readPassword(bundle.getString("MSG_EnterKeystorePassword"));
509 if (passwd == null) {
510 signJarParams.storePass = "";
511 } else {
512 signJarParams.storePass = new String(passwd);
513 }
514 }
515 if (signJarParams.keyPass == null) {
516 char[] passwd = System.console().readPassword(bundle.getString("MSG_EnterKeyPassword"), signJarParams.alias);
517 if (passwd == null) {
518 signJarParams.keyPass = "";
519 } else {
520 signJarParams.keyPass = new String(passwd);
521 }
522 }
523 packager.signJar(signJarParams);
524 }
525 if (makeAll) {
526 makeAllParams.validate();
527 packager.makeAll(makeAllParams);
528 }
529
530 } catch (Exception e) {
531 if (verbose) {
532 throw e;
533 } else {
534 System.err.println(e.getMessage());
535 if (e.getCause() != null && e.getCause() != e) {
536 System.err.println(e.getCause().getMessage());
537 }
538 System.exit(-1);
539 }
540 }
541 }
542 }
543
544 private static final String MODULE = "--" + StandardBundlerParam.MODULE.getID();
545 private static final String M = "-m";
546 private static final String MODULE_PATH = "--" + StandardBundlerParam.MODULE_PATH.getID();
547 private static final String P = "-p";
548 private static final String ADD_MODULES = "--" + StandardBundlerParam.ADD_MODULES.getID();
549 private static final String LIMIT_MODULES = "--" + StandardBundlerParam.LIMIT_MODULES.getID();
550 private static final String STRIP_NATIVE_COMMANDS = "--" + StandardBundlerParam.STRIP_NATIVE_COMMANDS.getID();
551
552 private static final String J_XDEBUG = JLinkBundlerHelper.DEBUG.getID() + ":";
553 private static final String DETECT_MODULES = "--" + JLinkBundlerHelper.DETECT_MODULES.getID();
554
555 public static void showBundlerHelp(String bundlerName, boolean verbose) {
556 //TODO I18N
557 if ("bundlers".equals(bundlerName)) {
558 // enumerate bundlers
559 System.out.println("Known Bundlers -- \n");
560 for (Bundler bundler : Bundlers.createBundlersInstance().getBundlers()) {
561 try {
562 bundler.validate(new HashMap<>());
563 } catch (UnsupportedPlatformException upe) {
564 // don't list bundlers this platform cannot run
565 continue;
566 } catch (ConfigException ignore) {
567 // but requiring more than an empty map is perfectly fine.
568 //} catch (RuntimeException re) {
569 // re.printStackTrace();
570 }
571
572 if (verbose) {
573 System.out.printf(
574 "%s - %s - %s\n\t%s\n",
575 bundler.getID(),
576 bundler.getName(),
577 bundler.getBundleType(),
578 bundler.getDescription()
579 );
580 } else {
581 System.out.printf(
582 "%s - %s - %s\n",
583 bundler.getID(),
584 bundler.getName(),
585 bundler.getBundleType()
586 );
587 }
588 }
589 } else {
590 // enumerate parameters for a bundler
591 for (Bundler bundler : Bundlers.createBundlersInstance().getBundlers()) {
592 if (bundler.getID().equals(bundlerName)) {
593 System.out.printf("Bundler Parameters for %s (%s) --\n", bundler.getName(), bundler.getID());
594 for (BundlerParamInfo bpi : bundler.getBundleParameters()) {
595 if (bpi.getStringConverter() == null) continue;
596 if (verbose) {
597 System.out.printf(
598 "%s - %s - %s\n\t%s\n",
599 bpi.getID(),
600 bpi.getName(),
601 bpi.getValueType().getSimpleName(),
602 bpi.getDescription()
603 );
604 } else {
605 System.out.printf(
606 "%s - %s - %s\n",
607 bpi.getID(),
608 bpi.getName(),
609 bpi.getValueType().getSimpleName()
610 );
611 }
612 }
613 return;
614 }
615 }
616 System.out.printf("Sorry, no bundler matching the id %s was found.\n", bundlerName);
617 }
618 }
619 }