1 /*
   2  * Copyright (c) 2015, 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.tools.jlink.builder;
  27 
  28 import java.io.BufferedOutputStream;
  29 import java.io.BufferedWriter;
  30 import java.io.ByteArrayInputStream;
  31 import java.io.DataOutputStream;
  32 import java.io.File;
  33 import java.io.FileInputStream;
  34 import java.io.FileOutputStream;
  35 import java.io.IOException;
  36 import java.io.InputStream;
  37 import java.io.OutputStream;
  38 import java.io.OutputStreamWriter;
  39 import java.io.UncheckedIOException;
  40 import java.io.Writer;
  41 import java.lang.module.ModuleDescriptor;
  42 import java.nio.charset.StandardCharsets;
  43 import java.nio.file.FileAlreadyExistsException;
  44 import java.nio.file.Files;
  45 import java.nio.file.Path;
  46 import java.nio.file.Paths;
  47 import java.nio.file.StandardOpenOption;
  48 import java.nio.file.attribute.PosixFilePermission;
  49 import java.util.Collections;
  50 import java.util.HashMap;
  51 import java.util.HashSet;
  52 import java.util.List;
  53 import java.util.Map;
  54 import java.util.Objects;
  55 import java.util.Optional;
  56 import java.util.Properties;
  57 import java.util.Set;
  58 import static java.util.stream.Collectors.*;
  59 
  60 import jdk.tools.jlink.internal.BasicImageWriter;

  61 import jdk.tools.jlink.internal.ExecutableImage;
  62 import jdk.tools.jlink.plugin.ResourcePool;
  63 import jdk.tools.jlink.plugin.ResourcePoolEntry;
  64 import jdk.tools.jlink.plugin.ResourcePoolEntry.Type;
  65 import jdk.tools.jlink.plugin.ResourcePoolModule;
  66 import jdk.tools.jlink.plugin.PluginException;
  67 
  68 /**
  69  *
  70  * Default Image Builder. This builder creates the default runtime image layout.
  71  */
  72 public final class DefaultImageBuilder implements ImageBuilder {
  73     // Top-level directory names in a modular runtime image
  74     public static final String BIN_DIRNAME      = "bin";
  75     public static final String CONF_DIRNAME     = "conf";
  76     public static final String INCLUDE_DIRNAME  = "include";
  77     public static final String LIB_DIRNAME      = "lib";
  78     public static final String LEGAL_DIRNAME    = "legal";
  79     public static final String MAN_DIRNAME      = "man";
  80 
  81     /**
  82      * The default java executable Image.
  83      */
  84     static final class DefaultExecutableImage implements ExecutableImage {
  85 
  86         private final Path home;
  87         private final List<String> args;
  88         private final Set<String> modules;
  89 
  90         DefaultExecutableImage(Path home, Set<String> modules) {
  91             Objects.requireNonNull(home);
  92             if (!Files.exists(home)) {
  93                 throw new IllegalArgumentException("Invalid image home");
  94             }
  95             this.home = home;
  96             this.modules = Collections.unmodifiableSet(modules);
  97             this.args = createArgs(home);
  98         }
  99 
 100         private static List<String> createArgs(Path home) {
 101             Objects.requireNonNull(home);
 102             Path binDir = home.resolve("bin");
 103             String java = Files.exists(binDir.resolve("java"))? "java" : "java.exe";
 104             return List.of(binDir.resolve(java).toString());
 105         }
 106 
 107         @Override
 108         public Path getHome() {
 109             return home;
 110         }
 111 
 112         @Override
 113         public Set<String> getModules() {
 114             return modules;
 115         }
 116 
 117         @Override
 118         public List<String> getExecutionArgs() {
 119             return args;
 120         }
 121 
 122         @Override
 123         public void storeLaunchArgs(List<String> args) {
 124             try {
 125                 patchScripts(this, args);
 126             } catch (IOException ex) {
 127                 throw new UncheckedIOException(ex);
 128             }
 129         }
 130     }
 131 
 132     private final Path root;
 133     private final Path mdir;
 134     private final Set<String> modules = new HashSet<>();
 135     private String targetOsName;
 136 
 137     /**
 138      * Default image builder constructor.
 139      *
 140      * @param root The image root directory.
 141      * @throws IOException
 142      */
 143     public DefaultImageBuilder(Path root) throws IOException {
 144         Objects.requireNonNull(root);
 145 
 146         this.root = root;
 147         this.mdir = root.resolve("lib");
 148         Files.createDirectories(mdir);
 149     }
 150 














 151     @Override
 152     public void storeFiles(ResourcePool files) {
 153         try {
 154             // populate targetOsName field up-front because it's used elsewhere.
 155             Optional<ResourcePoolModule> javaBase = files.moduleView().findModule("java.base");
 156             javaBase.ifPresent(mod -> {
 157                 // fill release information available from transformed "java.base" module!
 158                 ModuleDescriptor desc = mod.descriptor();
 159                 desc.osName().ifPresent(s -> {
 160                     this.targetOsName = s;
 161                 });
 162             });
 163 
 164             if (this.targetOsName == null) {
 165                 throw new PluginException("TargetPlatform attribute is missing for java.base module");
 166             }
 167 



 168             Path bin = root.resolve(BIN_DIRNAME);
 169 
 170             // check any duplicated resource files
 171             Map<Path, Set<String>> duplicates = new HashMap<>();
 172             files.entries()
 173                 .filter(f -> f.type() != ResourcePoolEntry.Type.CLASS_OR_RESOURCE)
 174                 .collect(groupingBy(this::entryToImagePath,
 175                          mapping(ResourcePoolEntry::moduleName, toSet())))
 176                 .entrySet()
 177                 .stream()
 178                 .filter(e -> e.getValue().size() > 1)
 179                 .forEach(e -> duplicates.put(e.getKey(), e.getValue()));
 180 
 181             // write non-classes resource files to the image
 182             files.entries()
 183                 .filter(f -> f.type() != ResourcePoolEntry.Type.CLASS_OR_RESOURCE)
 184                 .forEach(f -> {
 185                     try {
 186                         accept(f);
 187                     } catch (FileAlreadyExistsException e) {
 188                         // error for duplicated entries
 189                         Path path = entryToImagePath(f);
 190                         UncheckedIOException x =
 191                             new UncheckedIOException(path + " duplicated in " +
 192                                     duplicates.get(path), e);
 193                         x.addSuppressed(e);
 194                         throw x;
 195                     } catch (IOException ioExp) {
 196                         throw new UncheckedIOException(ioExp);
 197                     }
 198                 });
 199 
 200             files.moduleView().modules().forEach(m -> {
 201                 // Only add modules that contain packages
 202                 if (!m.packages().isEmpty()) {
 203                     modules.add(m.name());
 204                 }
 205             });
 206 
 207             if (root.getFileSystem().supportedFileAttributeViews()
 208                     .contains("posix")) {
 209                 // launchers in the bin directory need execute permission.
 210                 // On Windows, "bin" also subdirectories containing jvm.dll.
 211                 if (Files.isDirectory(bin)) {
 212                     Files.find(bin, 2, (path, attrs) -> {
 213                         return attrs.isRegularFile() && !path.toString().endsWith(".diz");
 214                     }).forEach(this::setExecutable);
 215                 }
 216 
 217                 // jspawnhelper is in lib or lib/<arch>
 218                 Path lib = root.resolve(LIB_DIRNAME);
 219                 if (Files.isDirectory(lib)) {
 220                     Files.find(lib, 2, (path, attrs) -> {
 221                         return path.getFileName().toString().equals("jspawnhelper")
 222                                 || path.getFileName().toString().equals("jexec");
 223                     }).forEach(this::setExecutable);
 224                 }
 225 
 226                 // read-only legal notices/license files
 227                 Path legal = root.resolve(LEGAL_DIRNAME);
 228                 if (Files.isDirectory(legal)) {
 229                     Files.find(legal, 2, (path, attrs) -> {
 230                         return attrs.isRegularFile();
 231                     }).forEach(this::setReadOnly);
 232                 }
 233             }
 234 
 235             // If native files are stripped completely, <root>/bin dir won't exist!
 236             // So, don't bother generating launcher scripts.
 237             if (Files.isDirectory(bin)) {
 238                  prepareApplicationFiles(files, modules);
 239             }
 240         } catch (IOException ex) {
 241             throw new PluginException(ex);
 242         }
 243     }
 244 
 245     /**
 246      * Generates launcher scripts.
 247      *
 248      * @param imageContent The image content.
 249      * @param modules The set of modules that the runtime image contains.
 250      * @throws IOException
 251      */
 252     protected void prepareApplicationFiles(ResourcePool imageContent, Set<String> modules) throws IOException {
 253         // generate launch scripts for the modules with a main class
 254         for (String module : modules) {
 255             String path = "/" + module + "/module-info.class";
 256             Optional<ResourcePoolEntry> res = imageContent.findEntry(path);
 257             if (!res.isPresent()) {
 258                 throw new IOException("module-info.class not found for " + module + " module");
 259             }
 260             Optional<String> mainClass;
 261             ByteArrayInputStream stream = new ByteArrayInputStream(res.get().contentBytes());
 262             mainClass = ModuleDescriptor.read(stream).mainClass();
 263             if (mainClass.isPresent()) {
 264                 Path cmd = root.resolve("bin").resolve(module);
 265                 // generate shell script for Unix platforms
 266                 StringBuilder sb = new StringBuilder();
 267                 sb.append("#!/bin/sh")
 268                         .append("\n");
 269                 sb.append("JLINK_VM_OPTIONS=")
 270                         .append("\n");
 271                 sb.append("DIR=`dirname $0`")
 272                         .append("\n");
 273                 sb.append("$DIR/java $JLINK_VM_OPTIONS -m ")
 274                         .append(module).append('/')
 275                         .append(mainClass.get())
 276                         .append(" $@\n");
 277 
 278                 try (BufferedWriter writer = Files.newBufferedWriter(cmd,
 279                         StandardCharsets.ISO_8859_1,
 280                         StandardOpenOption.CREATE_NEW)) {
 281                     writer.write(sb.toString());
 282                 }
 283                 if (root.resolve("bin").getFileSystem()
 284                         .supportedFileAttributeViews().contains("posix")) {
 285                     setExecutable(cmd);
 286                 }
 287                 // generate .bat file for Windows
 288                 if (isWindows()) {
 289                     Path bat = root.resolve(BIN_DIRNAME).resolve(module + ".bat");
 290                     sb = new StringBuilder();
 291                     sb.append("@echo off")
 292                             .append("\r\n");
 293                     sb.append("set JLINK_VM_OPTIONS=")
 294                             .append("\r\n");
 295                     sb.append("set DIR=%~dp0")
 296                             .append("\r\n");
 297                     sb.append("\"%DIR%\\java\" %JLINK_VM_OPTIONS% -m ")
 298                             .append(module).append('/')
 299                             .append(mainClass.get())
 300                             .append(" %*\r\n");
 301 
 302                     try (BufferedWriter writer = Files.newBufferedWriter(bat,
 303                             StandardCharsets.ISO_8859_1,
 304                             StandardOpenOption.CREATE_NEW)) {
 305                         writer.write(sb.toString());
 306                     }
 307                 }
 308             }
 309         }
 310     }
 311 
 312     @Override
 313     public DataOutputStream getJImageOutputStream() {
 314         try {
 315             Path jimageFile = mdir.resolve(BasicImageWriter.MODULES_IMAGE_NAME);
 316             OutputStream fos = Files.newOutputStream(jimageFile);
 317             BufferedOutputStream bos = new BufferedOutputStream(fos);
 318             return new DataOutputStream(bos);
 319         } catch (IOException ex) {
 320             throw new UncheckedIOException(ex);
 321         }
 322     }
 323 
 324     /**
 325      * Returns the file name of this entry
 326      */
 327     private String entryToFileName(ResourcePoolEntry entry) {
 328         if (entry.type() == ResourcePoolEntry.Type.CLASS_OR_RESOURCE)
 329             throw new IllegalArgumentException("invalid type: " + entry);
 330 
 331         String module = "/" + entry.moduleName() + "/";
 332         String filename = entry.path().substring(module.length());
 333 
 334         // Remove radical native|config|...
 335         return filename.substring(filename.indexOf('/') + 1);
 336     }
 337 
 338     /**
 339      * Returns the path of the given entry to be written in the image
 340      */
 341     private Path entryToImagePath(ResourcePoolEntry entry) {
 342         switch (entry.type()) {
 343             case NATIVE_LIB:
 344                 String filename = entryToFileName(entry);
 345                 return Paths.get(nativeDir(filename), filename);
 346             case NATIVE_CMD:
 347                 return Paths.get(BIN_DIRNAME, entryToFileName(entry));
 348             case CONFIG:
 349                 return Paths.get(CONF_DIRNAME, entryToFileName(entry));
 350             case HEADER_FILE:
 351                 return Paths.get(INCLUDE_DIRNAME, entryToFileName(entry));
 352             case MAN_PAGE:
 353                 return Paths.get(MAN_DIRNAME, entryToFileName(entry));
 354             case LEGAL_NOTICE:
 355                 return Paths.get(LEGAL_DIRNAME, entryToFileName(entry));
 356             case TOP:
 357                 return Paths.get(entryToFileName(entry));


 358             default:
 359                 throw new IllegalArgumentException("invalid type: " + entry);
 360         }
 361     }
 362 
 363     private void accept(ResourcePoolEntry file) throws IOException {
 364         if (file.linkedTarget() != null && file.type() != Type.LEGAL_NOTICE) {
 365             throw new UnsupportedOperationException("symbolic link not implemented: " + file);
 366         }
 367 
 368         try (InputStream in = file.content()) {
 369             switch (file.type()) {
 370                 case NATIVE_LIB:
 371                     Path dest = root.resolve(entryToImagePath(file));
 372                     writeEntry(in, dest);
 373                     break;
 374                 case NATIVE_CMD:
 375                     Path p = root.resolve(entryToImagePath(file));
 376                     writeEntry(in, p);
 377                     p.toFile().setExecutable(true);
 378                     break;
 379                 case CONFIG:
 380                 case HEADER_FILE:
 381                 case MAN_PAGE:
 382                     writeEntry(in, root.resolve(entryToImagePath(file)));
 383                     break;
 384                 case LEGAL_NOTICE:
 385                     Path source = entryToImagePath(file);
 386                     if (file.linkedTarget() == null) {
 387                         writeEntry(in, root.resolve(source));
 388                     } else {
 389                         Path target = entryToImagePath(file.linkedTarget());
 390                         Path relPath = source.getParent().relativize(target);
 391                         writeSymLinkEntry(root.resolve(source), relPath);
 392                     }
 393                     break;
 394                 case TOP:
 395                     // Copy TOP files of the "java.base" module (only)
 396                     if ("java.base".equals(file.moduleName())) {
 397                         writeEntry(in, root.resolve(entryToImagePath(file)));










 398                     }
 399                     break;
 400                 default:
 401                     throw new InternalError("unexpected entry: " + file.path());
 402             }
 403         }
 404     }
 405 
 406     private void writeEntry(InputStream in, Path dstFile) throws IOException {
 407         Objects.requireNonNull(in);
 408         Objects.requireNonNull(dstFile);
 409         Files.createDirectories(Objects.requireNonNull(dstFile.getParent()));
 410         Files.copy(in, dstFile);
 411     }
 412 
 413     private void writeSymEntry(Path dstFile, Path target) throws IOException {
 414         Objects.requireNonNull(dstFile);
 415         Objects.requireNonNull(target);
 416         Files.createDirectories(Objects.requireNonNull(dstFile.getParent()));
 417         Files.createLink(dstFile, target);
 418     }
 419 
 420     /*
 421      * Create a symbolic link to the given target if the target platform
 422      * supports symbolic link; otherwise, it will create a tiny file
 423      * to contain the path to the target.
 424      */
 425     private void writeSymLinkEntry(Path dstFile, Path target) throws IOException {
 426         Objects.requireNonNull(dstFile);
 427         Objects.requireNonNull(target);
 428         Files.createDirectories(Objects.requireNonNull(dstFile.getParent()));
 429         if (!isWindows() && root.getFileSystem()
 430                                 .supportedFileAttributeViews()
 431                                 .contains("posix")) {
 432             Files.createSymbolicLink(dstFile, target);
 433         } else {
 434             try (BufferedWriter writer = Files.newBufferedWriter(dstFile)) {
 435                 writer.write(String.format("Please see %s%n", target.toString()));
 436             }
 437         }
 438     }
 439 
 440     private String nativeDir(String filename) {
 441         if (isWindows()) {
 442             if (filename.endsWith(".dll") || filename.endsWith(".diz")
 443                     || filename.endsWith(".pdb") || filename.endsWith(".map")) {
 444                 return BIN_DIRNAME;
 445             } else {
 446                 return LIB_DIRNAME;
 447             }
 448         } else {
 449             return LIB_DIRNAME;
 450         }
 451     }
 452 
 453     private boolean isWindows() {
 454         return targetOsName.startsWith("Windows");
 455     }
 456 
 457     /**
 458      * chmod ugo+x file
 459      */
 460     private void setExecutable(Path file) {
 461         try {
 462             Set<PosixFilePermission> perms = Files.getPosixFilePermissions(file);
 463             perms.add(PosixFilePermission.OWNER_EXECUTE);
 464             perms.add(PosixFilePermission.GROUP_EXECUTE);
 465             perms.add(PosixFilePermission.OTHERS_EXECUTE);
 466             Files.setPosixFilePermissions(file, perms);
 467         } catch (IOException ioe) {
 468             throw new UncheckedIOException(ioe);
 469         }
 470     }
 471 
 472     /**
 473      * chmod ugo-w file
 474      */
 475     private void setReadOnly(Path file) {
 476         try {
 477             Set<PosixFilePermission> perms = Files.getPosixFilePermissions(file);
 478             perms.remove(PosixFilePermission.OWNER_WRITE);
 479             perms.remove(PosixFilePermission.GROUP_WRITE);
 480             perms.remove(PosixFilePermission.OTHERS_WRITE);
 481             Files.setPosixFilePermissions(file, perms);
 482         } catch (IOException ioe) {
 483             throw new UncheckedIOException(ioe);
 484         }
 485     }
 486 
 487     private static void createUtf8File(File file, String content) throws IOException {
 488         try (OutputStream fout = new FileOutputStream(file);
 489                 Writer output = new OutputStreamWriter(fout, "UTF-8")) {
 490             output.write(content);
 491         }
 492     }
 493 
 494     @Override
 495     public ExecutableImage getExecutableImage() {
 496         return new DefaultExecutableImage(root, modules);
 497     }
 498 
 499     // This is experimental, we should get rid-off the scripts in a near future
 500     private static void patchScripts(ExecutableImage img, List<String> args) throws IOException {
 501         Objects.requireNonNull(args);
 502         if (!args.isEmpty()) {
 503             Files.find(img.getHome().resolve(BIN_DIRNAME), 2, (path, attrs) -> {
 504                 return img.getModules().contains(path.getFileName().toString());
 505             }).forEach((p) -> {
 506                 try {
 507                     String pattern = "JLINK_VM_OPTIONS=";
 508                     byte[] content = Files.readAllBytes(p);
 509                     String str = new String(content, StandardCharsets.UTF_8);
 510                     int index = str.indexOf(pattern);
 511                     StringBuilder builder = new StringBuilder();
 512                     if (index != -1) {
 513                         builder.append(str.substring(0, index)).
 514                                 append(pattern);
 515                         for (String s : args) {
 516                             builder.append(s).append(" ");
 517                         }
 518                         String remain = str.substring(index + pattern.length());
 519                         builder.append(remain);
 520                         str = builder.toString();
 521                         try (BufferedWriter writer = Files.newBufferedWriter(p,
 522                                 StandardCharsets.ISO_8859_1,
 523                                 StandardOpenOption.WRITE)) {
 524                             writer.write(str);
 525                         }
 526                     }
 527                 } catch (IOException ex) {
 528                     throw new RuntimeException(ex);
 529                 }
 530             });
 531         }
 532     }
 533 
 534     public static ExecutableImage getExecutableImage(Path root) {
 535         Path binDir = root.resolve(BIN_DIRNAME);
 536         if (Files.exists(binDir.resolve("java")) ||
 537             Files.exists(binDir.resolve("java.exe"))) {
 538             return new DefaultExecutableImage(root, retrieveModules(root));
 539         }
 540         return null;
 541     }
 542 
 543     private static Set<String> retrieveModules(Path root) {
 544         Path releaseFile = root.resolve("release");
 545         Set<String> modules = new HashSet<>();
 546         if (Files.exists(releaseFile)) {
 547             Properties release = new Properties();
 548             try (FileInputStream fi = new FileInputStream(releaseFile.toFile())) {
 549                 release.load(fi);
 550             } catch (IOException ex) {
 551                 System.err.println("Can't read release file " + ex);
 552             }
 553             String mods = release.getProperty("MODULES");
 554             if (mods != null) {
 555                 String[] arr = mods.substring(1, mods.length() - 1).split(" ");
 556                 for (String m : arr) {
 557                     modules.add(m.trim());
 558                 }
 559 
 560             }
 561         }
 562         return modules;
 563     }
 564 }
--- EOF ---