1 /*
2 * Copyright (c) 2018, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 package jnlp.converter;
25
26 import java.io.File;
27 import java.util.ArrayList;
28 import java.util.List;
29
30 public class Options {
31
32 private boolean createImage = false;
33 private boolean createInstaller = false;
34 private String installerType = null;
35 private String jnlp = null;
36 private String output = null;
37 private String keep = null;
38 private boolean help = false;
39 private boolean verbose = false;
40 private boolean version = false;
41 private final List<String> jpackagerOptions = new ArrayList<>();
42 private boolean isRuntimeImageSet = false;
43
44 private static final String JNLP_OPTION_PREFIX = "--jnlp=";
45 private static final String OUTPUT_OPTION_PREFIX = "--output=";
46 private static final String KEEP_OPTION_PREFIX = "--keep=";
47 private static final String JNLP_OPTION_SHORT_PREFIX = "-j";
48 private static final String OUTPUT_OPTION_SHORT_PREFIX = "-o";
49 private static final String KEEP_OPTION_SHORT_PREFIX = "-k";
50
51 private static final String [] INSTALLER_TYPES = {"msi", "rpm", "deb",
52 "dmg", "pkg", "pkg-app-store"};
53
54 // --output, -o, --input, -i, --files, -f, --main-jar, -j, --class, -c
55 private static final String [] BLOCKED_JPACKAGER_OPTIONS = {"--output", "-o", "--input", "-i",
56 "--files", "-f", "--main-jar",
57 "-j", "--class", "-c"};
58
59 private static final String RUNTIME_IMAGE_OPTION = "--runtime-image";
60
61 private static final String ERR_UNKNOWN_OPTION = "Unknown option: ";
62 private static final String ERR_MISSING_VALUE = "Value is required for option ";
63 private static final String ERR_MISSING_MODE = "Error: create-image or create-installer mode is required";
64 private static final String ERR_MISSING_JNLP = "Error: --jnlp is required";
65 private static final String ERR_MISSING_OUTPUT = "Error: --output is required";
66 private static final String ERR_OUTPUT_EXISTS = "Error: output folder already exists";
67 private static final String ERR_KEEP_EXISTS = "Error: folder for --keep argument already exists";
68 private static final String ERR_INVALID_PROTOCOL_JNLP = "Error: Invalid protocol for JNLP file. Only HTTP, HTTPS and FILE protocols are supported.";
69
70 public boolean createImage() {
71 return createImage;
72 }
73
74 public boolean createInstaller() {
75 return createInstaller;
76 }
77
78 public String getInstallerType() {
79 return installerType;
80 }
81
82 public String getJNLP() {
83 return jnlp;
84 }
85
86 public String getOutput() {
87 return output;
88 }
89
90 public String keep() {
91 return keep;
92 }
93
94 public boolean help() {
95 return help;
96 }
97
98 public boolean verbose() {
99 return verbose;
100 }
101
102 public boolean version() {
103 return version;
104 }
105
106 public List<String> getJPackagerOptions() {
107 return jpackagerOptions;
108 }
109
110 public boolean isRuntimeImageSet() {
111 return isRuntimeImageSet;
112 }
113
114 // Helper method to dump all options
115 private void display() {
116 System.out.println("Options:");
117 System.out.println("createImage: " + createImage);
118 System.out.println("createInstaller: " + createInstaller);
119 System.out.println("installerType: " + installerType);
120 System.out.println("jnlp: " + jnlp);
121 System.out.println("output: " + output);
122 System.out.println("keep: " + keep);
123 System.out.println("help: " + help);
124 System.out.println("verbose: " + verbose);
125 System.out.println("version: " + version);
126 for (int i = 0; i < jpackagerOptions.size(); i++) {
127 System.out.println("jpackagerOptions[" + i + "]: " + jpackagerOptions.get(i));
128 }
129 }
130
131 private void validate() {
132 if (help || version) {
133 return;
134 }
135
136 if (!createImage && !createInstaller) {
137 optionError(ERR_MISSING_MODE);
138 }
139
140 if (jnlp == null) {
141 optionError(ERR_MISSING_JNLP);
142 } else {
143 int index = jnlp.indexOf(":");
144 if (index == -1 || index == 0) {
145 optionError(ERR_INVALID_PROTOCOL_JNLP);
146 } else {
147 String protocol = jnlp.substring(0, index);
148 if (!protocol.equalsIgnoreCase("http") &&
149 !protocol.equalsIgnoreCase("https") &&
150 !protocol.equalsIgnoreCase("file")) {
151 optionError(ERR_INVALID_PROTOCOL_JNLP);
152 }
153 }
154 }
155
156 if (output == null) {
157 optionError(ERR_MISSING_OUTPUT);
158 } else {
159 File file = new File(output);
160 if (file.exists()) {
161 optionErrorNoHelp(ERR_OUTPUT_EXISTS);
162 }
163 }
164
165 if (keep != null) {
166 File file = new File(keep);
167 if (file.exists()) {
168 optionErrorNoHelp(ERR_KEEP_EXISTS);
169 }
170 }
171
172 jpackagerOptions.forEach((option) -> {
173 if (isBlockedOption(option)) {
174 Log.error(option + " is not allowed via --jpackager-options, since it will conflict with "
175 + "same option generated by JNLPConverter.");
176 }
177 });
178 }
179
180 public boolean isOptionPresent(String option) {
181 for (String jpackagerOption : jpackagerOptions) {
182 if (jpackagerOption.equalsIgnoreCase(option)) {
183 return true;
184 }
185 }
186
187 return false;
188 }
189
190 private boolean isBlockedOption(String option) {
191 for (String blockedOption : BLOCKED_JPACKAGER_OPTIONS) {
192 if (blockedOption.equalsIgnoreCase(option)) {
193 return true;
194 }
195 }
196
197 return false;
198 }
199
200 public static void showHelp() {
201 // System.out.println("********* Help should not be longer then 80 characters as per JEP-293 *********");
202 System.out.println("Usage: java -jar JNLPConverter.jar <mode> <options>");
203 System.out.println("");
204 System.out.println("where mode is one of:");
205 System.out.println(" create-image");
206 System.out.println(" Generates a platform-specific application image.");
207 System.out.println(" create-installer <type>");
208 System.out.println(" Generates a platform-specific installer for the application.");
209 System.out.println(" Valid values for \"type\" are \"msi\", \"rpm\", \"deb\", \"dmg\", \"pkg\",");
210 System.out.println(" \"pkg-app-store\". If \"type\" is omitted, all supported types of installable");
211 System.out.println(" packages for current platform will be generated.");
212 System.out.println("");
213 System.out.println("Possible options include:");
214 System.out.println(" -j, --jnlp <path>");
215 System.out.println(" Full path to JNLP file. Supported protocols are HTTP/HTTPS/FILE.");
216 System.out.println(" -o, --output <path>");
217 System.out.println(" Name of the directory where generated output files are placed.");
218 System.out.println(" -k, --keep <path>");
219 System.out.println(" Keep JNLP, JARs and command line arguments for jpackager");
220 System.out.println(" in directory provided.");
221 System.out.println(" --jpackager-options <options>");
222 System.out.println(" Specify additional jpackager options or overwrite provided by JNLPConverter.");
223 System.out.println(" All jpackager options can be specified except: --output -o, --input -i,");
224 System.out.println(" --files -f, --main-jar -j and --class -c.");
225 System.out.println(" -h, --help, -?");
226 System.out.println(" Print this help message");
227 System.out.println(" -v, --verbose");
228 System.out.println(" Enable verbose output.");
229 System.out.println(" --version");
230 System.out.println(" Version information.");
231 System.out.println("To specify an argument for a long option, you can use --<name>=<value> or");
232 System.out.println("--<name> <value>.");
233 System.out.println("To specify proxy server use standard Java properties http.proxyHost and http.proxyPort.");
234 }
235
236 private static boolean isInstallerType(String type) {
237 for (String installerType : INSTALLER_TYPES) {
238 if (installerType.equals(type)) {
239 return true;
240 }
241 }
242
243 return false;
244 }
245
246 public static Options parseArgs(String[] args) {
247 Options options = new Options();
248
249 int index = 0;
250 if (args.length >= 1) {
251 switch (args[0]) {
252 case "create-image":
253 options.createImage = true;
254 index = 1;
255 break;
256 case "create-installer":
257 options.createInstaller = true;
258 index = 1;
259 if (args.length >= 2) {
260 if (isInstallerType(args[1])) {
261 options.installerType = args[1];
262 index = 2;
263 }
264 }
265 break;
266 case "-h":
267 case "--help":
268 case "-?":
269 case "--version":
270 break;
271 default:
272 optionError(Options.ERR_MISSING_MODE);
273 break;
274 }
275 }
276
277 for (int i = index; i < args.length; i++) {
278 String arg = args[i];
279
280 if (arg.equals("--jnlp")) {
281 if (++i >= args.length) {
282 optionError(Options.ERR_MISSING_VALUE, "--jnlp");
283 }
284 options.jnlp = args[i];
285 } else if (arg.startsWith(JNLP_OPTION_PREFIX)) {
286 options.jnlp = arg.substring(JNLP_OPTION_PREFIX.length());
287 } else if (arg.equals("--output")) {
288 if (++i >= args.length) {
289 optionError(Options.ERR_MISSING_VALUE, "--output");
290 }
291 options.output = args[i];
292 } else if (arg.startsWith(OUTPUT_OPTION_PREFIX)) {
293 options.output = arg.substring(OUTPUT_OPTION_PREFIX.length());
294 } else if (arg.equals("--keep")) {
295 if (++i >= args.length) {
296 optionError(Options.ERR_MISSING_VALUE, "--keep");
297 }
298 options.keep = args[i];
299 } else if (arg.startsWith(KEEP_OPTION_PREFIX)) {
300 options.keep = arg.substring(KEEP_OPTION_PREFIX.length());
301 } else if (arg.equals("--help")) {
302 options.help = true;
303 } else if (arg.equals("--verbose")) {
304 options.verbose = true;
305 } else if (arg.equals("--version")) {
306 options.version = true;
307 } else if (arg.equals("-j")) { // short options
308 if (++i >= args.length) {
309 optionError(Options.ERR_MISSING_VALUE, "-j");
310 }
311 options.jnlp = args[i];
312 } else if (arg.startsWith(JNLP_OPTION_SHORT_PREFIX)) {
313 options.jnlp = arg.substring(JNLP_OPTION_SHORT_PREFIX.length());
314 } else if (arg.equals("-o")) {
315 if (++i >= args.length) {
316 optionError(Options.ERR_MISSING_VALUE, "-o");
317 }
318 options.output = args[i];
319 } else if (arg.startsWith(OUTPUT_OPTION_SHORT_PREFIX)) {
320 options.output = arg.substring(OUTPUT_OPTION_SHORT_PREFIX.length());
321 } else if (arg.equals("-k")) {
322 if (++i >= args.length) {
323 optionError(Options.ERR_MISSING_VALUE, "-k");
324 }
325 options.keep = args[i];
326 } else if (arg.startsWith(KEEP_OPTION_SHORT_PREFIX)) {
327 options.keep = arg.substring(KEEP_OPTION_SHORT_PREFIX.length());
328 } else if (arg.equals("-h") || arg.equals("-?")) {
329 options.help = true;
330 } else if (arg.equals("-v")) {
331 options.verbose = true;
332 } else if (arg.equals("--jpackager-options")) {
333 for (i = (i + 1); i < args.length; i++) {
334 if (!options.isRuntimeImageSet) {
335 if (args[i].equals(RUNTIME_IMAGE_OPTION)) {
336 options.isRuntimeImageSet = true;
337 }
338 }
339 options.jpackagerOptions.add(args[i]);
340 }
341 } else {
342 optionError(ERR_UNKNOWN_OPTION, arg);
343 }
344 }
345
346 //options.display(); // For testing only
347 options.validate();
348
349 return options;
350 }
351
352 private static void optionErrorNoHelp(String msg) {
353 System.out.println(msg);
354 System.exit(1);
355 }
356
357 private static void optionError(String msg) {
358 System.out.println(msg);
359 System.out.println();
360 showHelp();
361 System.exit(1);
362 }
363
364 private static void optionError(String msg, String option) {
365 System.out.println(msg + option);
366 System.out.println();
367 showHelp();
368 System.exit(1);
369 }
370 }