1 /*
   2  * Copyright (c) 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 package jdk.incubator.jpackage.internal;
  26 
  27 import java.io.*;
  28 import java.nio.file.InvalidPathException;
  29 import java.nio.file.Path;
  30 import java.text.MessageFormat;
  31 import java.util.*;
  32 import java.util.function.Function;
  33 import java.util.function.Predicate;
  34 import java.util.stream.Collectors;
  35 import java.util.stream.Stream;
  36 import static jdk.incubator.jpackage.internal.DesktopIntegration.*;
  37 import static jdk.incubator.jpackage.internal.LinuxAppBundler.LINUX_INSTALL_DIR;
  38 import static jdk.incubator.jpackage.internal.LinuxAppBundler.LINUX_PACKAGE_DEPENDENCIES;
  39 import static jdk.incubator.jpackage.internal.StandardBundlerParam.*;
  40 
  41 
  42 abstract class LinuxPackageBundler extends AbstractBundler {
  43 
  44     LinuxPackageBundler(BundlerParamInfo<String> packageName) {
  45         this.packageName = packageName;
  46     }
  47 
  48     @Override
  49     final public boolean validate(Map<String, ? super Object> params)
  50             throws ConfigException {
  51 
  52         // run basic validation to ensure requirements are met
  53         // we are not interested in return code, only possible exception
  54         APP_BUNDLER.fetchFrom(params).validate(params);
  55 
  56         validateInstallDir(LINUX_INSTALL_DIR.fetchFrom(params));
  57 
  58         validateFileAssociations(FILE_ASSOCIATIONS.fetchFrom(params));
  59 
  60         // If package name has some restrictions, the string converter will
  61         // throw an exception if invalid
  62         packageName.getStringConverter().apply(packageName.fetchFrom(params),
  63             params);
  64 
  65         for (var validator: getToolValidators(params)) {
  66             ConfigException ex = validator.validate();
  67             if (ex != null) {
  68                 throw ex;
  69             }
  70         }
  71 
  72         withFindNeededPackages = LibProvidersLookup.supported();
  73         if (!withFindNeededPackages) {
  74             final String advice;
  75             if ("deb".equals(getID())) {
  76                 advice = "message.deb-ldd-not-available.advice";
  77             } else {
  78                 advice = "message.rpm-ldd-not-available.advice";
  79             }
  80             // Let user know package dependencies will not be generated.
  81             Log.error(String.format("%s\n%s", I18N.getString(
  82                     "message.ldd-not-available"), I18N.getString(advice)));
  83         }
  84 
  85         // Packaging specific validation
  86         doValidate(params);
  87 
  88         return true;
  89     }
  90 
  91     @Override
  92     final public String getBundleType() {
  93         return "INSTALLER";
  94     }
  95 
  96     @Override
  97     final public File execute(Map<String, ? super Object> params,
  98             File outputParentDir) throws PackagerException {
  99         IOUtils.writableOutputDir(outputParentDir.toPath());
 100 
 101         PlatformPackage thePackage = createMetaPackage(params);
 102 
 103         Function<File, ApplicationLayout> initAppImageLayout = imageRoot -> {
 104             ApplicationLayout layout = appImageLayout(params);
 105             layout.pathGroup().setPath(new Object(),
 106                     AppImageFile.getPathInAppImage(Path.of("")));
 107             return layout.resolveAt(imageRoot.toPath());
 108         };
 109 
 110         try {
 111             File appImage = StandardBundlerParam.getPredefinedAppImage(params);
 112 
 113             // we either have an application image or need to build one
 114             if (appImage != null) {
 115                 initAppImageLayout.apply(appImage).copy(
 116                         thePackage.sourceApplicationLayout());
 117             } else {
 118                 appImage = APP_BUNDLER.fetchFrom(params).doBundle(params,
 119                         thePackage.sourceRoot().toFile(), true);
 120                 ApplicationLayout srcAppLayout = initAppImageLayout.apply(
 121                         appImage);
 122                 if (appImage.equals(PREDEFINED_RUNTIME_IMAGE.fetchFrom(params))) {
 123                     // Application image points to run-time image.
 124                     // Copy it.
 125                     srcAppLayout.copy(thePackage.sourceApplicationLayout());
 126                 } else {
 127                     // Application image is a newly created directory tree.
 128                     // Move it.
 129                     srcAppLayout.move(thePackage.sourceApplicationLayout());
 130                     if (appImage.exists()) {
 131                         // Empty app image directory might remain after all application
 132                         // directories have been moved.
 133                         appImage.delete();
 134                     }
 135                 }
 136             }
 137 
 138             if (!StandardBundlerParam.isRuntimeInstaller(params)) {
 139                 desktopIntegration = new DesktopIntegration(thePackage, params);
 140             } else {
 141                 desktopIntegration = null;
 142             }
 143 
 144             Map<String, String> data = createDefaultReplacementData(params);
 145             if (desktopIntegration != null) {
 146                 data.putAll(desktopIntegration.create());
 147             } else {
 148                 Stream.of(DESKTOP_COMMANDS_INSTALL, DESKTOP_COMMANDS_UNINSTALL,
 149                         UTILITY_SCRIPTS).forEach(v -> data.put(v, ""));
 150             }
 151 
 152             data.putAll(createReplacementData(params));
 153 
 154             File packageBundle = buildPackageBundle(Collections.unmodifiableMap(
 155                     data), params, outputParentDir);
 156 
 157             verifyOutputBundle(params, packageBundle.toPath()).stream()
 158                     .filter(Objects::nonNull)
 159                     .forEachOrdered(ex -> {
 160                 Log.verbose(ex.getLocalizedMessage());
 161                 Log.verbose(ex.getAdvice());
 162             });
 163 
 164             return packageBundle;
 165         } catch (IOException ex) {
 166             Log.verbose(ex);
 167             throw new PackagerException(ex);
 168         }
 169     }
 170 
 171     private List<String> getListOfNeededPackages(
 172             Map<String, ? super Object> params) throws IOException {
 173 
 174         PlatformPackage thePackage = createMetaPackage(params);
 175 
 176         final List<String> xdgUtilsPackage;
 177         if (desktopIntegration != null) {
 178             xdgUtilsPackage = desktopIntegration.requiredPackages();
 179         } else {
 180             xdgUtilsPackage = Collections.emptyList();
 181         }
 182 
 183         final List<String> neededLibPackages;
 184         if (withFindNeededPackages) {
 185             LibProvidersLookup lookup = new LibProvidersLookup();
 186             initLibProvidersLookup(params, lookup);
 187 
 188             neededLibPackages = lookup.execute(thePackage.sourceRoot());
 189         } else {
 190             neededLibPackages = Collections.emptyList();
 191         }
 192 
 193         // Merge all package lists together.
 194         // Filter out empty names, sort and remove duplicates.
 195         List<String> result = Stream.of(xdgUtilsPackage, neededLibPackages).flatMap(
 196                 List::stream).filter(Predicate.not(String::isEmpty)).sorted().distinct().collect(
 197                 Collectors.toList());
 198 
 199         Log.verbose(String.format("Required packages: %s", result));
 200 
 201         return result;
 202     }
 203 
 204     private Map<String, String> createDefaultReplacementData(
 205             Map<String, ? super Object> params) throws IOException {
 206         Map<String, String> data = new HashMap<>();
 207 
 208         data.put("APPLICATION_PACKAGE", createMetaPackage(params).name());
 209         data.put("APPLICATION_VENDOR", VENDOR.fetchFrom(params));
 210         data.put("APPLICATION_VERSION", VERSION.fetchFrom(params));
 211         data.put("APPLICATION_DESCRIPTION", DESCRIPTION.fetchFrom(params));
 212         data.put("APPLICATION_RELEASE", RELEASE.fetchFrom(params));
 213 
 214         String defaultDeps = String.join(", ", getListOfNeededPackages(params));
 215         String customDeps = LINUX_PACKAGE_DEPENDENCIES.fetchFrom(params).strip();
 216         if (!customDeps.isEmpty() && !defaultDeps.isEmpty()) {
 217             customDeps = ", " + customDeps;
 218         }
 219         data.put("PACKAGE_DEFAULT_DEPENDENCIES", defaultDeps);
 220         data.put("PACKAGE_CUSTOM_DEPENDENCIES", customDeps);
 221 
 222         return data;
 223     }
 224 
 225     abstract protected List<ConfigException> verifyOutputBundle(
 226             Map<String, ? super Object> params, Path packageBundle);
 227 
 228     abstract protected void initLibProvidersLookup(
 229             Map<String, ? super Object> params,
 230             LibProvidersLookup libProvidersLookup);
 231 
 232     abstract protected List<ToolValidator> getToolValidators(
 233             Map<String, ? super Object> params);
 234 
 235     abstract protected void doValidate(Map<String, ? super Object> params)
 236             throws ConfigException;
 237 
 238     abstract protected Map<String, String> createReplacementData(
 239             Map<String, ? super Object> params) throws IOException;
 240 
 241     abstract protected File buildPackageBundle(
 242             Map<String, String> replacementData,
 243             Map<String, ? super Object> params, File outputParentDir) throws
 244             PackagerException, IOException;
 245 
 246     final protected PlatformPackage createMetaPackage(
 247             Map<String, ? super Object> params) {
 248         return new PlatformPackage() {
 249             @Override
 250             public String name() {
 251                 return packageName.fetchFrom(params);
 252             }
 253 
 254             @Override
 255             public Path sourceRoot() {
 256                 return IMAGES_ROOT.fetchFrom(params).toPath().toAbsolutePath();
 257             }
 258 
 259             @Override
 260             public ApplicationLayout sourceApplicationLayout() {
 261                 return appImageLayout(params).resolveAt(
 262                         applicationInstallDir(sourceRoot()));
 263             }
 264 
 265             @Override
 266             public ApplicationLayout installedApplicationLayout() {
 267                 return appImageLayout(params).resolveAt(
 268                         applicationInstallDir(Path.of("/")));
 269             }
 270 
 271             private Path applicationInstallDir(Path root) {
 272                 Path installDir = Path.of(LINUX_INSTALL_DIR.fetchFrom(params),
 273                         name());
 274                 if (installDir.isAbsolute()) {
 275                     installDir = Path.of("." + installDir.toString()).normalize();
 276                 }
 277                 return root.resolve(installDir);
 278             }
 279         };
 280     }
 281 
 282     private ApplicationLayout appImageLayout(
 283             Map<String, ? super Object> params) {
 284         if (StandardBundlerParam.isRuntimeInstaller(params)) {
 285             return ApplicationLayout.javaRuntime();
 286         }
 287         return ApplicationLayout.linuxAppImage();
 288     }
 289 
 290     private static void validateInstallDir(String installDir) throws
 291             ConfigException {
 292         if (installDir.startsWith("/usr/") || installDir.equals("/usr")) {
 293             throw new ConfigException(MessageFormat.format(I18N.getString(
 294                     "error.unsupported-install-dir"), installDir), null);
 295         }
 296 
 297         if (installDir.isEmpty()) {
 298             throw new ConfigException(MessageFormat.format(I18N.getString(
 299                     "error.invalid-install-dir"), "/"), null);
 300         }
 301 
 302         boolean valid = false;
 303         try {
 304             final Path installDirPath = Path.of(installDir);
 305             valid = installDirPath.isAbsolute();
 306             if (valid && !installDirPath.normalize().toString().equals(
 307                     installDirPath.toString())) {
 308                 // Don't allow '/opt/foo/..' or /opt/.
 309                 valid = false;
 310             }
 311         } catch (InvalidPathException ex) {
 312         }
 313 
 314         if (!valid) {
 315             throw new ConfigException(MessageFormat.format(I18N.getString(
 316                     "error.invalid-install-dir"), installDir), null);
 317         }
 318     }
 319 
 320     private static void validateFileAssociations(
 321             List<Map<String, ? super Object>> associations) throws
 322             ConfigException {
 323         // only one mime type per association, at least one file extention
 324         int assocIdx = 0;
 325         for (var assoc : associations) {
 326             ++assocIdx;
 327             List<String> mimes = FA_CONTENT_TYPE.fetchFrom(assoc);
 328             if (mimes == null || mimes.isEmpty()) {
 329                 String msgKey = "error.no-content-types-for-file-association";
 330                 throw new ConfigException(
 331                         MessageFormat.format(I18N.getString(msgKey), assocIdx),
 332                         I18N.getString(msgKey + ".advise"));
 333 
 334             }
 335 
 336             if (mimes.size() > 1) {
 337                 String msgKey = "error.too-many-content-types-for-file-association";
 338                 throw new ConfigException(
 339                         MessageFormat.format(I18N.getString(msgKey), assocIdx),
 340                         I18N.getString(msgKey + ".advise"));
 341             }
 342         }
 343     }
 344 
 345     private final BundlerParamInfo<String> packageName;
 346     private boolean withFindNeededPackages;
 347     private DesktopIntegration desktopIntegration;
 348 
 349     private static final BundlerParamInfo<LinuxAppBundler> APP_BUNDLER =
 350         new StandardBundlerParam<>(
 351                 "linux.app.bundler",
 352                 LinuxAppBundler.class,
 353                 (params) -> new LinuxAppBundler(),
 354                 null
 355         );
 356 
 357 }