1 /*
   2  * Copyright (c) 2011, 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.nio.file.Files;
  30 import java.nio.file.Path;
  31 import java.nio.file.InvalidPathException;
  32 import java.text.MessageFormat;
  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 targetFormat = null; // means default type for this platform
  56 
  57     File outdir = null;
  58 
  59     // raw arguments to the bundler
  60     Map<String, ? super Object> bundlerArguments = new LinkedHashMap<>();
  61 
  62     public void setOutput(File output) {
  63         outdir = output;
  64     }
  65 
  66     static class Template {
  67         File in;
  68         File out;
  69 
  70         Template(File in, File out) {
  71             this.in = in;
  72             this.out = out;
  73         }
  74     }
  75 
  76     // we need to expand as in some cases
  77     // (most notably jpackage)
  78     // we may get "." as filename and assumption is we include
  79     // everything in the given folder
  80     // (IOUtils.copyfiles() have recursive behavior)
  81     List<File> expandFileset(File root) {
  82         List<File> files = new LinkedList<>();
  83         if (!Files.isSymbolicLink(root.toPath())) {
  84             if (root.isDirectory()) {
  85                 File[] children = root.listFiles();
  86                 if (children != null) {
  87                     for (File f : children) {
  88                         files.addAll(expandFileset(f));
  89                     }
  90                 }
  91             } else {
  92                 files.add(root);
  93             }
  94         }
  95         return files;
  96     }
  97 
  98     public void addResource(File baseDir, String path) {
  99         addResource(baseDir, new File(baseDir, path));
 100     }
 101 
 102     public void addResource(File baseDir, File file) {
 103         // normalize initial file
 104         // to strip things like "." in the path
 105         // or it can confuse symlink detection logic
 106         file = file.getAbsoluteFile();
 107 
 108         if (baseDir == null) {
 109             baseDir = file.getParentFile();
 110         }
 111         resources.add(new RelativeFileSet(
 112                 baseDir, new LinkedHashSet<>(expandFileset(file))));
 113     }
 114 
 115     void setClasspath(String mainJarPath) {
 116         String classpath;
 117         // we want main jar first on the classpath
 118         if (mainJarPath != null) {
 119             classpath = mainJarPath + File.pathSeparator;
 120         } else {
 121             classpath = "";
 122         }
 123         for (RelativeFileSet resource : resources) {
 124              for (String file : resource.getIncludedFiles()) {
 125                  if (file.endsWith(".jar")) {
 126                      if (!file.equals(mainJarPath)) {
 127                          classpath += file + File.pathSeparator;
 128                      }
 129                  }
 130              }
 131         }
 132         addBundleArgument(
 133                 StandardBundlerParam.CLASSPATH.getID(), classpath);
 134     }
 135 
 136     static void validateName(String s, boolean forApp)
 137             throws PackagerException {
 138 
 139         String exceptionKey = forApp ?
 140             "ERR_InvalidAppName" : "ERR_InvalidSLName";
 141 
 142         if (s == null) {
 143             if (forApp) {
 144                 return;
 145             } else {
 146                 throw new PackagerException(exceptionKey, s);
 147             }
 148         }
 149         if (s.length() == 0 || s.charAt(s.length() - 1) == '\\') {
 150             throw new PackagerException(exceptionKey, s);
 151         }
 152         try {
 153             // name must be valid path element for this file system
 154             Path p = (new File(s)).toPath();
 155             // and it must be a single name element in a path
 156             if (p.getNameCount() != 1) {
 157                 throw new PackagerException(exceptionKey, s);
 158             }
 159         } catch (InvalidPathException ipe) {
 160             throw new PackagerException(ipe, exceptionKey, s);
 161         }
 162 
 163         for (int i = 0; i < s.length(); i++) {
 164             char a = s.charAt(i);
 165             // We check for ASCII codes first which we accept. If check fails,
 166             // check if it is acceptable extended ASCII or unicode character.
 167             if (a < ' ' || a > '~') {
 168                 // Accept anything else including special chars like copyright
 169                 // symbols. Note: space will be included by ASCII check above,
 170                 // but other whitespace like tabs or new line will be rejected.
 171                 if (Character.isISOControl(a)  ||
 172                         Character.isWhitespace(a)) {
 173                     throw new PackagerException(exceptionKey, s);
 174                 }
 175             } else if (a == '"' || a == '%') {
 176                 throw new PackagerException(exceptionKey, s);
 177             }
 178         }
 179     }
 180 
 181     public void validate() throws PackagerException {
 182         boolean hasModule = (bundlerArguments.get(
 183                 Arguments.CLIOptions.MODULE.getId()) != null);
 184         boolean hasAppImage = (bundlerArguments.get(
 185                 Arguments.CLIOptions.PREDEFINED_APP_IMAGE.getId()) != null);
 186         boolean hasClass = (bundlerArguments.get(
 187                 Arguments.CLIOptions.APPCLASS.getId()) != null);
 188         boolean hasMain = (bundlerArguments.get(
 189                 Arguments.CLIOptions.MAIN_JAR.getId()) != null);
 190         boolean hasRuntimeImage = (bundlerArguments.get(
 191                 Arguments.CLIOptions.PREDEFINED_RUNTIME_IMAGE.getId()) != null);
 192         boolean hasInput = (bundlerArguments.get(
 193                 Arguments.CLIOptions.INPUT.getId()) != null);
 194         boolean hasModulePath = (bundlerArguments.get(
 195                 Arguments.CLIOptions.MODULE_PATH.getId()) != null);
 196         boolean runtimeInstaller = !isTargetAppImage() &&
 197                 !hasAppImage && !hasModule && !hasMain && hasRuntimeImage;
 198 
 199         if (isTargetAppImage()) {
 200             // Module application requires --runtime-image or --module-path
 201             if (hasModule) {
 202                 if (!hasModulePath && !hasRuntimeImage) {
 203                     throw new PackagerException("ERR_MissingArgument",
 204                             "--runtime-image or --module-path");
 205                 }
 206             } else {
 207                 if (!hasInput) {
 208                     throw new PackagerException(
 209                            "ERR_MissingArgument", "--input");
 210                 }
 211             }
 212         } else {
 213             if (!runtimeInstaller) {
 214                 if (hasModule) {
 215                     if (!hasModulePath && !hasRuntimeImage && !hasAppImage) {
 216                         throw new PackagerException("ERR_MissingArgument",
 217                             "--runtime-image, --module-path or --app-image");
 218                     }
 219                 } else {
 220                     if (!hasInput && !hasAppImage) {
 221                         throw new PackagerException("ERR_MissingArgument",
 222                                 "--input or --app-image");
 223                     }
 224                 }
 225             }
 226         }
 227 
 228         // if bundling non-modular image, or installer without app-image
 229         // then we need some resources and a main class
 230         if (!hasModule && !hasAppImage && !runtimeInstaller) {
 231             if (resources.isEmpty()) {
 232                 throw new PackagerException("ERR_MissingAppResources");
 233             }
 234             if (!hasMain) {
 235                 throw new PackagerException("ERR_MissingArgument",
 236                         "--main-jar");
 237             }
 238         }
 239 
 240         String name = (String)bundlerArguments.get(
 241                 Arguments.CLIOptions.NAME.getId());
 242         validateName(name, true);
 243 
 244         // Validate app image if set
 245         String appImage = (String)bundlerArguments.get(
 246                 Arguments.CLIOptions.PREDEFINED_APP_IMAGE.getId());
 247         if (appImage != null) {
 248             File appImageDir = new File(appImage);
 249             if (!appImageDir.exists() || appImageDir.list().length == 0) {
 250                 throw new PackagerException("ERR_AppImageNotExist", appImage);
 251             }
 252         }
 253 
 254         // Validate temp dir
 255         String root = (String)bundlerArguments.get(
 256                 Arguments.CLIOptions.TEMP_ROOT.getId());
 257         if (root != null) {
 258             String [] contents = (new File(root)).list();
 259 
 260             if (contents != null && contents.length > 0) {
 261                 throw new PackagerException("ERR_BuildRootInvalid", root);
 262             }
 263         }
 264 

























 265         // Validate license file if set
 266         String license = (String)bundlerArguments.get(
 267                 Arguments.CLIOptions.LICENSE_FILE.getId());
 268         if (license != null) {
 269             File licenseFile = new File(license);
 270             if (!licenseFile.exists()) {
 271                 throw new PackagerException("ERR_LicenseFileNotExit");
 272             }
 273         }
 274     }
 275 
 276     void setTargetFormat(String t) {
 277         targetFormat = t;
 278     }
 279 
 280     String getTargetFormat() {
 281         return targetFormat;
 282     }
 283 
 284     boolean isTargetAppImage() {
 285         return ("app-image".equals(targetFormat));
 286     }
 287 
 288     private static final Set<String> multi_args = new TreeSet<>(Arrays.asList(
 289             StandardBundlerParam.JAVA_OPTIONS.getID(),
 290             StandardBundlerParam.ARGUMENTS.getID(),
 291             StandardBundlerParam.MODULE_PATH.getID(),
 292             StandardBundlerParam.ADD_MODULES.getID(),
 293             StandardBundlerParam.LIMIT_MODULES.getID(),
 294             StandardBundlerParam.FILE_ASSOCIATIONS.getID()
 295     ));
 296 
 297     @SuppressWarnings("unchecked")
 298     public void addBundleArgument(String key, Object value) {
 299         // special hack for multi-line arguments
 300         if (multi_args.contains(key)) {
 301             Object existingValue = bundlerArguments.get(key);
 302             if (existingValue instanceof String && value instanceof String) {
 303                 String delim = "\n\n";
 304                 if (key.equals(StandardBundlerParam.MODULE_PATH.getID())) {
 305                     delim = File.pathSeparator;
 306                 } else if (key.equals(
 307                         StandardBundlerParam.ADD_MODULES.getID())) {
 308                     delim = ",";
 309                 }
 310                 bundlerArguments.put(key, existingValue + delim + value);
 311             } else if (existingValue instanceof List && value instanceof List) {
 312                 ((List)existingValue).addAll((List)value);
 313             } else if (existingValue instanceof Map &&
 314                 value instanceof String && ((String)value).contains("=")) {
 315                 String[] mapValues = ((String)value).split("=", 2);
 316                 ((Map)existingValue).put(mapValues[0], mapValues[1]);
 317             } else {
 318                 bundlerArguments.put(key, value);
 319             }
 320         } else {
 321             bundlerArguments.put(key, value);
 322         }
 323     }
 324 
 325     BundleParams getBundleParams() {
 326         BundleParams bundleParams = new BundleParams();
 327 
 328         // construct app resources relative to destination folder!
 329         bundleParams.setAppResourcesList(resources);
 330 
 331         Map<String, String> unescapedHtmlParams = new TreeMap<>();
 332         Map<String, String> escapedHtmlParams = new TreeMap<>();
 333 
 334         // check for collisions
 335         TreeSet<String> keys = new TreeSet<>(bundlerArguments.keySet());
 336         keys.retainAll(bundleParams.getBundleParamsAsMap().keySet());
 337 
 338         if (!keys.isEmpty()) {
 339             throw new RuntimeException("Deploy Params and Bundler Arguments "
 340                     + "overlap in the following values:" + keys.toString());
 341         }
 342 
 343         bundleParams.addAllBundleParams(bundlerArguments);
 344 
 345         return bundleParams;
 346     }
 347 
 348     @Override
 349     public String toString() {
 350         return "DeployParams {" + "output: " + outdir
 351                 + " resources: {" + resources + "}}";
 352     }
 353 
 354 }
--- EOF ---