1 /*

     2  * Copyright (c) 2012, 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.jpackager.internal.bundlers;

    27 

    28 import jdk.jpackager.internal.*;

    29 import jdk.jpackager.internal.bundlers.BundlerType;

    30 import jdk.jpackager.internal.JLinkBundlerHelper;

    31 

    32 import java.io.File;

    33 import java.io.IOException;

    34 import java.util.*;

    35 import java.util.jar.Attributes;

    36 import java.util.jar.JarFile;

    37 import java.util.jar.Manifest;

    38 

    39 import static jdk.jpackager.internal.StandardBundlerParam.*;

    40 

    41 public class BundleParams {

    42 

    43     final protected Map<String, ? super Object> params;

    44 

    45     // RelativeFileSet

    46     public static final String PARAM_APP_RESOURCES      = "appResources";

    47 

    48     // BundlerType

    49     public static final String PARAM_TYPE               = "type";

    50 

    51     // String

    52     public static final String PARAM_BUNDLE_FORMAT      = "bundleFormat";

    53     // String

    54     public static final String PARAM_ICON               = "icon";

    55 

    56     // String - Name of bundle file and native launcher

    57     public static final String PARAM_NAME               = "name";

    58 

    59     // String - application vendor, used by most of the bundlers

    60     public static final String PARAM_VENDOR             = "vendor";

    61 

    62     // String - email name and email, only used for debian */

    63     public static final String PARAM_EMAIL              = "email";

    64 

    65     /* String - Copyright. Used on Mac */

    66     public static final String PARAM_COPYRIGHT          = "copyright";

    67 

    68     // String - GUID on windows for MSI, CFBundleIdentifier on Mac

    69     // If not compatible with requirements then bundler either do not bundle

    70     // or autogenerate

    71     public static final String PARAM_IDENTIFIER         = "identifier";

    72 

    73     /* boolean - shortcut preferences */

    74     public static final String PARAM_SHORTCUT           = "shortcutHint";

    75     // boolean - menu shortcut preference

    76     public static final String PARAM_MENU               = "menuHint";

    77 

    78     // String - Application version. Format may differ for different bundlers

    79     public static final String PARAM_VERSION            = "appVersion";

    80 

    81     // String - Application category. Used at least on Mac/Linux.

    82     // Value is platform specific

    83     public static final String PARAM_CATEGORY       = "applicationCategory";

    84 

    85     // String - Optional short application

    86     public static final String PARAM_TITLE              = "title";

    87 

    88     // String - Optional application description. Used by MSI and on Linux

    89     public static final String PARAM_DESCRIPTION        = "description";

    90 

    91     // String - License type. Needed on Linux (rpm)

    92     public static final String PARAM_LICENSE_TYPE       = "licenseType";

    93 

    94     // List<String> - File(s) with license. Format is OS/bundler specific

    95     public static final String PARAM_LICENSE_FILE       = "licenseFile";

    96 

    97     // boolean - service/daemon install.  null means "default"

    98     public static final String PARAM_SERVICE_HINT       = "serviceHint";

    99 

   100 

   101     // String Main application class.

   102     // Not used directly but used to derive default values

   103     public static final String PARAM_APPLICATION_CLASS  = "applicationClass";

   104 

   105     // boolean - Adds a dialog to let the user choose a directory

   106     // where the product will be installed.

   107     public static final String PARAM_INSTALLDIR_CHOOSER = "installdirChooser";

   108 

   109     // boolean - Prevents from launching multiple instances of application.

   110     public static final String PARAM_SINGLETON          = "singleton";

   111 

   112     /**

   113      * create a new bundle with all default values

   114      */

   115     public BundleParams() {

   116         params = new HashMap<>();

   117     }

   118 

   119     /**

   120      * Create a bundle params with a copy of the params

   121      * @param params map of initial parameters to be copied in.

   122      */

   123     public BundleParams(Map<String, ?> params) {

   124         this.params = new HashMap<>(params);

   125     }

   126 

   127     public void addAllBundleParams(Map<String, ? super Object> p) {

   128         params.putAll(p);

   129     }

   130 

   131     public <C> C fetchParam(BundlerParamInfo<C> paramInfo) {

   132         return paramInfo.fetchFrom(params);

   133     }

   134 

   135     @SuppressWarnings("unchecked")

   136     public <C> C fetchParamWithDefault(

   137             Class<C> klass, C defaultValue, String... keys) {

   138         for (String key : keys) {

   139             Object o = params.get(key);

   140             if (klass.isInstance(o)) {

   141                 return (C) o;

   142             } else if (params.containsKey(key) && o == null) {

   143                 return null;

   144             } else if (o != null) {

   145                 Log.debug("Bundle param " + key + " is not type " + klass);

   146             }

   147         }

   148         return defaultValue;

   149     }

   150 

   151     public <C> C fetchParam(Class<C> klass, String... keys) {

   152         return fetchParamWithDefault(klass, null, keys);

   153     }

   154 

   155     // NOTE: we do not care about application parameters here

   156     // as they will be embeded into jar file manifest and

   157     // java launcher will take care of them!

   158 

   159     public Map<String, ? super Object> getBundleParamsAsMap() {

   160         return new HashMap<>(params);

   161     }

   162 

   163     public void setJvmargs(List<String> jvmargs) {

   164         putUnlessNullOrEmpty(JVM_OPTIONS.getID(), jvmargs);

   165     }

   166 

   167     public void setJvmProperties(Map<String, String> jvmProperties) {

   168         putUnlessNullOrEmpty(JVM_PROPERTIES.getID(), jvmProperties);

   169     }

   170 

   171     public void setArguments(List<String> arguments) {

   172         putUnlessNullOrEmpty(ARGUMENTS.getID(), arguments);

   173     }

   174 

   175     public void setAddModules(String value) {

   176         putUnlessNull(StandardBundlerParam.ADD_MODULES.getID(), value);

   177     }

   178 

   179     public void setLimitModules(String value)  {

   180         putUnlessNull(StandardBundlerParam.LIMIT_MODULES.getID(), value);

   181     }

   182 

   183     public void setStripNativeCommands(boolean value) {

   184         putUnlessNull(StandardBundlerParam.STRIP_NATIVE_COMMANDS.getID(),

   185                 value);

   186     }

   187 

   188     public void setModulePath(String value) {

   189         putUnlessNull(StandardBundlerParam.MODULE_PATH.getID(), value);

   190     }

   191 

   192     public void setMainModule(String value) {

   193         putUnlessNull(StandardBundlerParam.MODULE.getID(), value);

   194     }

   195 

   196     public void setDebug(String value) {

   197         putUnlessNull(JLinkBundlerHelper.DEBUG.getID(), value);

   198     }

   199 

   200     public String getApplicationID() {

   201         return fetchParam(IDENTIFIER);

   202     }

   203 

   204     public String getPreferencesID() {

   205         return fetchParam(PREFERENCES_ID);

   206     }

   207 

   208     public String getTitle() {

   209         return fetchParam(TITLE);

   210     }

   211 

   212     public void setTitle(String title) {

   213         putUnlessNull(PARAM_TITLE, title);

   214     }

   215 

   216     public String getApplicationClass() {

   217         return fetchParam(MAIN_CLASS);

   218     }

   219 

   220     public void setApplicationClass(String applicationClass) {

   221         putUnlessNull(PARAM_APPLICATION_CLASS, applicationClass);

   222     }

   223 

   224     public String getAppVersion() {

   225         return fetchParam(VERSION);

   226     }

   227 

   228     public void setAppVersion(String version) {

   229         putUnlessNull(PARAM_VERSION, version);

   230     }

   231 

   232     public String getDescription() {

   233         return fetchParam(DESCRIPTION);

   234     }

   235 

   236     public void setDescription(String s) {

   237         putUnlessNull(PARAM_DESCRIPTION, s);

   238     }

   239 

   240     //path is relative to the application root

   241     public void addLicenseFile(String path) {

   242         List<String> licenseFiles = fetchParam(LICENSE_FILE);

   243         if (licenseFiles == null || licenseFiles.isEmpty()) {

   244             licenseFiles = new ArrayList<>();

   245             params.put(PARAM_LICENSE_FILE, licenseFiles);

   246         }

   247         licenseFiles.add(path);

   248     }

   249 

   250     public void setServiceHint(Boolean b) {

   251         putUnlessNull(PARAM_SERVICE_HINT, b);

   252     }

   253 

   254     public void setInstalldirChooser(Boolean b) {

   255         putUnlessNull(PARAM_INSTALLDIR_CHOOSER, b);

   256     }

   257 

   258     public void setSingleton(Boolean b) {

   259         putUnlessNull(PARAM_SINGLETON, b);

   260     }

   261 

   262     public String getName() {

   263         return fetchParam(APP_NAME);

   264     }

   265 

   266     public void setName(String name) {

   267         putUnlessNull(PARAM_NAME, name);

   268     }

   269 

   270     @SuppressWarnings("deprecation")

   271     public BundlerType getType() {

   272         return fetchParam(BundlerType.class, PARAM_TYPE);

   273     }

   274 

   275     @SuppressWarnings("deprecation")

   276     public void setType(BundlerType type) {

   277         putUnlessNull(PARAM_TYPE, type);

   278     }

   279 

   280     public String getBundleFormat() {

   281         return fetchParam(String.class, PARAM_BUNDLE_FORMAT);

   282     }

   283 

   284     public void setBundleFormat(String t) {

   285         putUnlessNull(PARAM_BUNDLE_FORMAT, t);

   286     }

   287 

   288     public boolean getVerbose() {

   289         return fetchParam(VERBOSE);

   290     }

   291 

   292     public List<String> getLicenseFile() {

   293         return fetchParam(LICENSE_FILE);

   294     }

   295 

   296     public List<String> getJvmargs() {

   297         return JVM_OPTIONS.fetchFrom(params);

   298     }

   299 

   300     public List<String> getArguments() {

   301         return ARGUMENTS.fetchFrom(params);

   302     }

   303 

   304     // Validation approach:

   305     //  - javac and

   306     //

   307     //  - /jmods dir

   308     // or

   309     //  - JRE marker (rt.jar)

   310     //  - FX marker (jfxrt.jar)

   311     //  - JDK marker (tools.jar)

   312     private static boolean checkJDKRoot(File jdkRoot) {

   313         String exe = (Platform.getPlatform() == Platform.WINDOWS) ?

   314                 ".exe" : "";

   315         File javac = new File(jdkRoot, "bin/javac" + exe);

   316         if (!javac.exists()) {

   317             Log.verbose("javac is not found at " + javac.getAbsolutePath());

   318             return false;

   319         }

   320 

   321         File jmods = new File(jdkRoot, "jmods");

   322         if (!jmods.exists()) {

   323             Log.verbose("jmods is not found in " + jdkRoot.getAbsolutePath());

   324             return false;

   325         }

   326         return true;

   327     }

   328 

   329     public jdk.jpackager.internal.RelativeFileSet getAppResource() {

   330         return fetchParam(APP_RESOURCES);

   331     }

   332 

   333     public void setAppResource(jdk.jpackager.internal.RelativeFileSet fs) {

   334         putUnlessNull(PARAM_APP_RESOURCES, fs);

   335     }

   336 

   337     public void setAppResourcesList(

   338             List<jdk.jpackager.internal.RelativeFileSet> rfs) {

   339         putUnlessNull(APP_RESOURCES_LIST.getID(), rfs);

   340     }

   341 

   342     public String getApplicationCategory() {

   343         return fetchParam(CATEGORY);

   344     }

   345 

   346     public void setApplicationCategory(String category) {

   347         putUnlessNull(PARAM_CATEGORY, category);

   348     }

   349 

   350     public String getMainClassName() {

   351         String applicationClass = getApplicationClass();

   352 

   353         if (applicationClass == null) {

   354             return null;

   355         }

   356 

   357         int idx = applicationClass.lastIndexOf(".");

   358         if (idx >= 0) {

   359             return applicationClass.substring(idx+1);

   360         }

   361         return applicationClass;

   362     }

   363 

   364     public String getCopyright() {

   365         return fetchParam(COPYRIGHT);

   366     }

   367 

   368     public void setCopyright(String c) {

   369         putUnlessNull(PARAM_COPYRIGHT, c);

   370     }

   371 

   372     public String getIdentifier() {

   373         return fetchParam(IDENTIFIER);

   374     }

   375 

   376     public void setIdentifier(String s) {

   377         putUnlessNull(PARAM_IDENTIFIER, s);

   378     }

   379 

   380     private String mainJar = null;

   381     private String mainJarClassPath = null;

   382     private boolean useFXPackaging = true;

   383 

   384     // For regular executable Jars we need to take care of classpath

   385     // For JavaFX executable jars we do not need to pay attention to

   386     // ClassPath entry in manifest

   387     public String getAppClassPath() {

   388         if (mainJar == null) {

   389             // this will find out answer

   390             getMainApplicationJar();

   391         }

   392         if (useFXPackaging || mainJarClassPath == null) {

   393             return "";

   394         }

   395         return mainJarClassPath;

   396     }

   397 

   398     // assuming that application was packaged according to the rules

   399     // we must have application jar, i.e. jar where we embed launcher

   400     // and have main application class listed as main class!

   401     // If there are more than one, or none - it will be treated as

   402     // deployment error

   403     //

   404     // Note we look for both JavaFX executable jars and regular executable jars

   405     // As long as main "application" entry point is the same it is main class

   406     // (i.e. for FX jar we will use JavaFX manifest entry ...)

   407     public String getMainApplicationJar() {

   408         jdk.jpackager.internal.RelativeFileSet appResources = getAppResource();

   409         if (mainJar != null) {

   410             if (getApplicationClass() == null) try {

   411                 if (appResources != null) {

   412                     File srcdir = appResources.getBaseDirectory();

   413                     JarFile jf = new JarFile(new File(srcdir, mainJar));

   414                     Manifest m = jf.getManifest();

   415                     Attributes attrs = (m != null) ?

   416                             m.getMainAttributes() : null;

   417                     if (attrs != null) {

   418                         setApplicationClass(

   419                                 attrs.getValue(Attributes.Name.MAIN_CLASS));

   420                     }

   421                 }

   422             } catch (IOException ignore) {

   423             }

   424             return mainJar;

   425         }

   426 

   427         String applicationClass = getApplicationClass();

   428 

   429         if (appResources == null || applicationClass == null) {

   430             return null;

   431         }

   432         File srcdir = appResources.getBaseDirectory();

   433         for (String fname : appResources.getIncludedFiles()) {

   434             JarFile jf;

   435             try {

   436                 jf = new JarFile(new File(srcdir, fname));

   437                 Manifest m = jf.getManifest();

   438                 Attributes attrs = (m != null) ? m.getMainAttributes() : null;

   439                 if (attrs != null) {

   440                     boolean javaMain = applicationClass.equals(

   441                                attrs.getValue(Attributes.Name.MAIN_CLASS));

   442 

   443                     if (javaMain) {

   444                         mainJar = fname;

   445                         mainJarClassPath = attrs.getValue(

   446                                Attributes.Name.CLASS_PATH);

   447                         return mainJar;

   448                     }

   449                 }

   450             } catch (IOException ignore) {

   451             }

   452         }

   453         return null;

   454     }

   455 

   456     public String getVendor() {

   457         return fetchParam(VENDOR);

   458     }

   459 

   460     public void setVendor(String vendor) {

   461        putUnlessNull(PARAM_VENDOR, vendor);

   462     }

   463 

   464     public String getEmail() {

   465         return fetchParam(String.class, PARAM_EMAIL);

   466     }

   467 

   468     public void setEmail(String email) {

   469         putUnlessNull(PARAM_EMAIL, email);

   470     }

   471 

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

   473         if (value != null) {

   474             params.put(param, value);

   475         }

   476     }

   477 

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

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

   480             params.put(param, value);

   481         }

   482     }

   483 

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

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

   486             params.put(param, value);

   487         }

   488     }

   489 

   490 }