1 /*

     2  * Copyright (c) 2011, 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.  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.packager.internal;

    27 

    28 import jdk.packager.internal.bundlers.BundlerType;

    29 import jdk.packager.internal.bundlers.BundleParams;

    30 

    31 import java.io.File;

    32 import java.nio.file.Files;

    33 import java.util.ArrayList;

    34 import java.util.Arrays;

    35 import java.util.Collection;

    36 import java.util.LinkedHashMap;

    37 import java.util.LinkedHashSet;

    38 import java.util.LinkedList;

    39 import java.util.List;

    40 import java.util.Map;

    41 import java.util.Set;

    42 import java.util.TreeMap;

    43 import java.util.TreeSet;

    44 

    45 /**

    46  * DeployParams

    47  *

    48  * This class is generated and used in Arguments.processArguments() as

    49  * intermediate step in generating the BundleParams and ultimately the Bundles

    50  */

    51 public class DeployParams {

    52 

    53     final List<RelativeFileSet> resources = new ArrayList<>();

    54 

    55     String id;

    56     String title;

    57     String vendor;

    58     String email;

    59     String description;

    60     String category;

    61     String licenseType;

    62     String copyright;

    63     String version;

    64     Boolean systemWide;

    65     Boolean serviceHint;

    66     Boolean signBundle;

    67     Boolean installdirChooser;

    68     Boolean singleton;

    69 

    70     String applicationClass;

    71 

    72     List<Param> params;

    73     List<String> arguments; //unnamed arguments

    74 

    75     // Java 9 modules support

    76     String addModules = null;

    77     String limitModules = null;

    78     Boolean stripNativeCommands = null;

    79     String modulePath = null;

    80     String module = null;

    81     String debugPort = null;

    82 

    83     boolean jreInstaller = false;

    84 

    85     File outdir = null;

    86 

    87     String appId = null;

    88 

    89     // list of jvm args

    90     // (in theory string can contain spaces and need to be escaped

    91     List<String> jvmargs = new LinkedList<>();

    92 

    93     // list of jvm properties (can also be passed as VM args

    94     // but keeping them separate make it a bit more convinient

    95     Map<String, String> properties = new LinkedHashMap<>();

    96 

    97     // raw arguments to the bundler

    98     Map<String, ? super Object> bundlerArguments = new LinkedHashMap<>();

    99 

   100     public void setId(String id) {

   101         this.id = id;

   102     }

   103 

   104     public void setCategory(String category) {

   105         this.category = category;

   106     }

   107 

   108     public void setLicenseType(String licenseType) {

   109         this.licenseType = licenseType;

   110     }

   111 

   112     public void setCopyright(String copyright) {

   113         this.copyright = copyright;

   114     }

   115 

   116     public void setVersion(String version) {

   117         this.version = version;

   118     }

   119 

   120     public void setSystemWide(Boolean systemWide) {

   121         this.systemWide = systemWide;

   122     }

   123 

   124     public void setServiceHint(Boolean serviceHint) {

   125         this.serviceHint = serviceHint;

   126     }

   127 

   128     public void setInstalldirChooser(Boolean installdirChooser) {

   129         this.installdirChooser = installdirChooser;

   130     }

   131 

   132     public void setSingleton(Boolean singleton) {

   133         this.singleton = singleton;

   134     }

   135 

   136     public void setSignBundle(Boolean signBundle) {

   137         this.signBundle = signBundle;

   138     }

   139 

   140     public void addJvmArg(String v) {

   141         jvmargs.add(v);

   142     }

   143 

   144     public void addJvmProperty(String n, String v) {

   145         properties.put(n, v);

   146     }

   147 

   148     public void setArguments(List<String> args) {

   149         this.arguments = args;

   150     }

   151 

   152     public List<String> getArguments() {

   153         return this.arguments;

   154     }

   155 

   156     public void addArgument(String arg) {

   157         this.arguments.add(arg);

   158     }

   159 

   160     public void addAddModule(String value) {

   161         if (addModules == null) {

   162             addModules = value;

   163         }

   164         else {

   165             addModules += "," + value;

   166         }

   167     }

   168 

   169     public void addLimitModule(String value) {

   170         if (limitModules == null) {

   171             limitModules = value;

   172         }

   173         else {

   174             limitModules += "," + value;

   175         }

   176     }

   177 

   178     public String getModulePath() {

   179         return this.modulePath;

   180     }

   181 

   182     public void setModulePath(String value) {

   183         this.modulePath = value;

   184     }

   185 

   186     public void setModule(String value) {

   187         this.module = value;

   188     }

   189 

   190     public void setDebug(String value) {

   191         this.debugPort = value;

   192     }

   193 

   194     public void setStripNativeCommands(boolean value) {

   195         this.stripNativeCommands = value;

   196     }

   197 

   198     public void setDescription(String description) {

   199         this.description = description;

   200     }

   201 

   202     public void setAppId(String id) {

   203         appId = id;

   204     }

   205 

   206     public void setParams(List<Param> params) {

   207         this.params = params;

   208     }

   209 

   210     public void setTitle(String title) {

   211         this.title = title;

   212     }

   213 

   214     public void setVendor(String vendor) {

   215         this.vendor = vendor;

   216     }

   217 

   218     public void setEmail(String email) {

   219         this.email = email;

   220     }

   221 

   222     public void setApplicationClass(String applicationClass) {

   223         this.applicationClass = applicationClass;

   224     }

   225 

   226     public void setJreInstaller(boolean value) {

   227         jreInstaller = value;

   228     }

   229 

   230     public File getOutput() {

   231         return outdir;

   232     }

   233 

   234     public void setOutput(File output) {

   235         outdir = output;

   236     }

   237 

   238     static class Template {

   239         File in;

   240         File out;

   241 

   242         Template(File in, File out) {

   243             this.in = in;

   244             this.out = out;

   245         }

   246     }

   247 

   248     // we need to expand as in some cases

   249     // (most notably jpackager)

   250     // we may get "." as filename and assumption is we include

   251     // everything in the given folder

   252     // (IOUtils.copyfiles() have recursive behavior)

   253     List<File> expandFileset(File root) {

   254         List<File> files = new LinkedList<>();

   255         if (!Files.isSymbolicLink(root.toPath())) {

   256             if (root.isDirectory()) {

   257                 File[] children = root.listFiles();

   258                 if (children != null) {

   259                     for (File f : children) {

   260                         files.addAll(expandFileset(f));

   261                     }

   262                 }

   263             } else {

   264                 files.add(root);

   265             }

   266         }

   267         return files;

   268     }

   269 

   270     public void addResource(File baseDir, String path) {

   271         File file = new File(baseDir, path);

   272         // normalize top level dir

   273         // to strip things like "." in the path

   274         // or it can confuse symlink detection logic

   275         file = file.getAbsoluteFile();

   276 

   277         if (baseDir == null) {

   278             baseDir = file.getParentFile();

   279         }

   280         resources.add(new RelativeFileSet(

   281                 baseDir, new LinkedHashSet<>(expandFileset(file))));

   282     }

   283 

   284     public void addResource(File baseDir, File file) {

   285         // normalize initial file

   286         // to strip things like "." in the path

   287         // or it can confuse symlink detection logic

   288         file = file.getAbsoluteFile();

   289 

   290         if (baseDir == null) {

   291             baseDir = file.getParentFile();

   292         }

   293         resources.add(new RelativeFileSet(

   294                 baseDir, new LinkedHashSet<>(expandFileset(file))));

   295     }

   296 

   297     private static File createFile(final File baseDir, final String path) {

   298         final File testFile = new File(path);

   299         return testFile.isAbsolute() ?

   300                 testFile : new File(baseDir == null ?

   301                         null : baseDir.getAbsolutePath(), path);

   302     }

   303 

   304     public static void validateAppName(String s) throws PackagerException {

   305         if (s == null || s.length() == 0) {

   306             // empty or null string - there is no unsupported char

   307             return;

   308         }

   309 

   310         int last = s.length() - 1;

   311 

   312         char fc = s.charAt(0);

   313         char lc = s.charAt(last);

   314 

   315         // illegal to end in backslash escape char

   316         if (lc == '\\') {

   317             throw new PackagerException("ERR_InvalidCharacterInArgument", "--name");

   318         }

   319 

   320         for (int i = 0; i < s.length(); i++) {

   321             char a = s.charAt(i);

   322             // We check for ASCII codes first which we accept. If check fails,

   323             // then check if it is acceptable extended ASCII or unicode character.

   324             if (a < ' ' || a > '~' || a == '%') {

   325                 // Reject '%', whitespaces and ISO Control.

   326                 // Accept anything else including special characters like copyright

   327                 // symbols. Note: space will be included by ASCII check above,

   328                 // but other whitespace like tabs or new line will be ignored.

   329                 if (Character.isISOControl(a) || Character.isWhitespace(a) || a == '%') {

   330                     throw new PackagerException("ERR_InvalidCharacterInArgument", "--name");

   331                 }

   332             }

   333             if (a == '"') {

   334                 throw new PackagerException("ERR_InvalidCharacterInArgument", "--name");

   335             }

   336         }

   337     }

   338 

   339     public void validate() throws PackagerException {

   340         if (outdir == null) {

   341             throw new PackagerException("ERR_MissingArgument", "--output");

   342         }

   343 

   344         boolean hasModule = (bundlerArguments.get(

   345                 Arguments.CLIOptions.MODULE.getId()) != null);

   346         boolean hasImage = (bundlerArguments.get(

   347                 Arguments.CLIOptions.PREDEFINED_APP_IMAGE.getId()) != null);

   348         boolean hasClass = (bundlerArguments.get(

   349                 Arguments.CLIOptions.APPCLASS.getId()) != null);

   350         boolean hasMain = (bundlerArguments.get(

   351                 Arguments.CLIOptions.MAIN_JAR.getId()) != null);

   352 

   353         // if bundling non-modular image, or installer without app-image

   354         // then we need some resources and a main class

   355         if (!hasModule && !hasImage && !jreInstaller) {

   356             if (resources.isEmpty()) {

   357                 throw new PackagerException("ERR_MissingAppResources");

   358             }

   359             if (!hasClass) {

   360                 throw new PackagerException("ERR_MissingArgument", "--class");

   361             }

   362             if (!hasMain) {

   363                 throw new PackagerException("ERR_MissingArgument",

   364                         "--main-jar");

   365             }

   366         }

   367 

   368         String name = (String)bundlerArguments.get(Arguments.CLIOptions.NAME.getId());

   369         validateAppName(name);

   370 

   371         // Validate app image if set

   372         String appImage = (String)bundlerArguments.get(

   373                 Arguments.CLIOptions.PREDEFINED_APP_IMAGE.getId());

   374         if (appImage != null) {

   375             File appImageDir = new File(appImage);

   376             if (!appImageDir.exists()) {

   377                 throw new PackagerException("ERR_AppImageNotExist", appImage);

   378             }

   379 

   380             File appImageAppDir = new File(appImage + File.separator + "app");

   381             File appImageRuntimeDir = new File(appImage

   382                     + File.separator + "runtime");

   383             if (!appImageAppDir.exists() || !appImageRuntimeDir.exists()) {

   384                 throw new PackagerException("ERR_AppImageInvalid", appImage);

   385             }

   386         }

   387     }

   388 

   389     public boolean validateForBundle() {

   390         boolean result = false;

   391 

   392         // Success

   393         if (((applicationClass != null && !applicationClass.isEmpty()) ||

   394             (module != null && !module.isEmpty()))) {

   395             result = true;

   396         }

   397 

   398         return result;

   399     }

   400 

   401     BundlerType bundleType = BundlerType.NONE;

   402     String targetFormat = null; //means any

   403 

   404     public void setBundleType(BundlerType type) {

   405         bundleType = type;

   406     }

   407 

   408     public BundlerType getBundleType() {

   409         return bundleType;

   410     }

   411 

   412     public void setTargetFormat(String t) {

   413         targetFormat = t;

   414     }

   415 

   416     public String getTargetFormat() {

   417         return targetFormat;

   418     }

   419 

   420     private String getArch() {

   421         String arch = System.getProperty("os.arch").toLowerCase();

   422 

   423         if ("x86".equals(arch) || "i386".equals(arch) || "i486".equals(arch)

   424                 || "i586".equals(arch) || "i686".equals(arch)) {

   425             arch = "x86";

   426         } else if ("x86_64".equals(arch) || "amd64".equals("arch")) {

   427             arch = "x86_64";

   428         }

   429 

   430         return arch;

   431     }

   432 

   433     static final Set<String> multi_args = new TreeSet<>(Arrays.asList(

   434             StandardBundlerParam.JVM_PROPERTIES.getID(),

   435             StandardBundlerParam.JVM_OPTIONS.getID(),

   436             StandardBundlerParam.ARGUMENTS.getID(),

   437             StandardBundlerParam.MODULE_PATH.getID(),

   438             StandardBundlerParam.ADD_MODULES.getID(),

   439             StandardBundlerParam.LIMIT_MODULES.getID(),

   440             StandardBundlerParam.FILE_ASSOCIATIONS.getID()

   441     ));

   442 

   443     @SuppressWarnings("unchecked")

   444     public void addBundleArgument(String key, Object value) {

   445         // special hack for multi-line arguments

   446         if (multi_args.contains(key)) {

   447             Object existingValue = bundlerArguments.get(key);

   448             if (existingValue instanceof String && value instanceof String) {

   449                 bundlerArguments.put(key, existingValue + "\n\n" + value);

   450             } else if (existingValue instanceof List && value instanceof List) {

   451                 ((List)existingValue).addAll((List)value);

   452             } else if (existingValue instanceof Map &&

   453                 value instanceof String && ((String)value).contains("=")) {

   454                 String[] mapValues = ((String)value).split("=", 2);

   455                 ((Map)existingValue).put(mapValues[0], mapValues[1]);

   456             } else {

   457                 bundlerArguments.put(key, value);

   458             }

   459         } else {

   460             bundlerArguments.put(key, value);

   461         }

   462     }

   463 

   464     public BundleParams getBundleParams() {

   465         BundleParams bundleParams = new BundleParams();

   466 

   467         //construct app resources

   468         //  relative to output folder!

   469         String currentOS = System.getProperty("os.name").toLowerCase();

   470         String currentArch = getArch();

   471 

   472         bundleParams.setAppResourcesList(resources);

   473 

   474         bundleParams.setIdentifier(id);

   475 

   476         bundleParams.setApplicationClass(applicationClass);

   477         bundleParams.setAppVersion(version);

   478         bundleParams.setType(bundleType);

   479         bundleParams.setBundleFormat(targetFormat);

   480         bundleParams.setVendor(vendor);

   481         bundleParams.setEmail(email);

   482         bundleParams.setServiceHint(serviceHint);

   483         bundleParams.setInstalldirChooser(installdirChooser);

   484         bundleParams.setSingleton(singleton);

   485         bundleParams.setCopyright(copyright);

   486         bundleParams.setApplicationCategory(category);

   487         bundleParams.setDescription(description);

   488         bundleParams.setTitle(title);

   489 

   490         bundleParams.setJvmProperties(properties);

   491         bundleParams.setJvmargs(jvmargs);

   492         bundleParams.setArguments(arguments);

   493 

   494         if (addModules != null && !addModules.isEmpty()) {

   495             bundleParams.setAddModules(addModules);

   496         }

   497 

   498         if (limitModules != null && !limitModules.isEmpty()) {

   499             bundleParams.setLimitModules(limitModules);

   500         }

   501 

   502         if (stripNativeCommands != null) {

   503             bundleParams.setStripNativeCommands(stripNativeCommands);

   504         }

   505 

   506         if (modulePath != null && !modulePath.isEmpty()) {

   507             bundleParams.setModulePath(modulePath);

   508         }

   509 

   510         if (module != null && !module.isEmpty()) {

   511             bundleParams.setMainModule(module);

   512         }

   513 

   514         if (debugPort != null && !debugPort.isEmpty()) {

   515             bundleParams.setDebug(debugPort);

   516         }

   517 

   518         Map<String, String> paramsMap = new TreeMap<>();

   519         if (params != null) {

   520             for (Param p : params) {

   521                 paramsMap.put(p.name, p.value);

   522             }

   523         }

   524 

   525         Map<String, String> unescapedHtmlParams = new TreeMap<>();

   526         Map<String, String> escapedHtmlParams = new TreeMap<>();

   527 

   528         // check for collisions

   529         TreeSet<String> keys = new TreeSet<>(bundlerArguments.keySet());

   530         keys.retainAll(bundleParams.getBundleParamsAsMap().keySet());

   531 

   532         if (!keys.isEmpty()) {

   533             throw new RuntimeException("Deploy Params and Bundler Arguments "

   534                     + "overlap in the following values:" + keys.toString());

   535         }

   536 

   537         bundleParams.addAllBundleParams(bundlerArguments);

   538 

   539         return bundleParams;

   540     }

   541 

   542     public Map<String, ? super Object> getBundlerArguments() {

   543         return this.bundlerArguments;

   544     }

   545 

   546     public void putUnlessNull(String param, Object value) {

   547         if (value != null) {

   548             bundlerArguments.put(param, value);

   549         }

   550     }

   551 

   552     public void putUnlessNullOrEmpty(String param, Map<?, ?> value) {

   553         if (value != null && !value.isEmpty()) {

   554             bundlerArguments.put(param, value);

   555         }

   556     }

   557 

   558     public void putUnlessNullOrEmpty(String param, Collection<?> value) {

   559         if (value != null && !value.isEmpty()) {

   560             bundlerArguments.put(param, value);

   561         }

   562     }

   563 

   564     @Override

   565     public String toString() {

   566         return "DeployParams{" + "outdir=" + outdir + '}';

   567     }

   568 

   569 }