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 com.sun.tools.jdeps;
  27 
  28 import static com.sun.tools.jdeps.Module.trace;
  29 import static java.util.stream.Collectors.*;
  30 
  31 import com.sun.tools.classfile.Dependency;
  32 
  33 import java.io.BufferedInputStream;
  34 import java.io.File;
  35 import java.io.FileNotFoundException;
  36 import java.io.IOException;
  37 import java.io.InputStream;
  38 import java.io.UncheckedIOException;
  39 import java.lang.module.Configuration;
  40 import java.lang.module.ModuleDescriptor;
  41 import java.lang.module.ModuleFinder;
  42 import java.lang.module.ModuleReader;
  43 import java.lang.module.ModuleReference;
  44 import java.lang.module.ResolvedModule;
  45 import java.net.URI;
  46 import java.nio.file.DirectoryStream;
  47 import java.nio.file.FileSystem;
  48 import java.nio.file.FileSystems;
  49 import java.nio.file.Files;
  50 import java.nio.file.Path;
  51 import java.nio.file.Paths;
  52 import java.util.ArrayList;
  53 import java.util.Collections;
  54 import java.util.HashMap;
  55 import java.util.HashSet;
  56 import java.util.LinkedHashMap;
  57 import java.util.LinkedHashSet;
  58 import java.util.List;
  59 import java.util.Map;
  60 import java.util.Objects;
  61 import java.util.Optional;
  62 import java.util.Set;
  63 import java.util.function.Function;
  64 import java.util.function.Supplier;
  65 import java.util.stream.Collectors;
  66 import java.util.stream.Stream;
  67 
  68 public class JdepsConfiguration implements AutoCloseable {
  69     // the token for "all modules on the module path"
  70     public static final String ALL_MODULE_PATH = "ALL-MODULE-PATH";
  71     public static final String ALL_DEFAULT = "ALL-DEFAULT";
  72     public static final String ALL_SYSTEM = "ALL-SYSTEM";
  73 
  74     public static final String MODULE_INFO = "module-info.class";
  75 
  76     private final SystemModuleFinder system;
  77     private final ModuleFinder finder;
  78 
  79     private final Map<String, Module> nameToModule = new LinkedHashMap<>();
  80     private final Map<String, Module> packageToModule = new HashMap<>();
  81     private final Map<String, List<Archive>> packageToUnnamedModule = new HashMap<>();
  82 
  83     private final List<Archive> classpathArchives = new ArrayList<>();
  84     private final List<Archive> initialArchives = new ArrayList<>();
  85     private final Set<Module> rootModules = new HashSet<>();

  86     private final Runtime.Version version;
  87 
  88     private JdepsConfiguration(Configuration config,
  89                                SystemModuleFinder systemModulePath,
  90                                ModuleFinder finder,
  91                                Set<String> roots,
  92                                List<Path> classpaths,
  93                                List<Archive> initialArchives,

  94                                Runtime.Version version)
  95         throws IOException
  96     {
  97         trace("root: %s%n", roots);

  98         this.system = systemModulePath;
  99         this.finder = finder;
 100         this.version = version;
 101 
 102         config.modules().stream()















 103               .map(ResolvedModule::reference)
 104               .forEach(this::addModuleReference);
 105 
 106         // packages in unnamed module
 107         initialArchives.forEach(archive -> {
 108             addPackagesInUnnamedModule(archive);
 109             this.initialArchives.add(archive);
 110         });
 111 
 112         // classpath archives
 113         for (Path p : classpaths) {
 114             if (Files.exists(p)) {
 115                 Archive archive = Archive.getInstance(p, version);
 116                 addPackagesInUnnamedModule(archive);
 117                 classpathArchives.add(archive);
 118             }
 119         }
 120 
 121         // all roots specified in --add-modules or -m are included
 122         // as the initial set for analysis.
 123         roots.stream()
 124              .map(nameToModule::get)
 125              .forEach(this.rootModules::add);
 126 
 127         initProfiles();
 128 
 129         trace("resolved modules: %s%n", nameToModule.keySet().stream()
 130                 .sorted().collect(joining("\n", "\n", "")));
 131     }
 132 
 133     private void initProfiles() {
 134         // other system modules are not observed and not added in nameToModule map
 135         Map<String, Module> systemModules =
 136             system.moduleNames()
 137                 .collect(toMap(Function.identity(), (mn) -> {
 138                     Module m = nameToModule.get(mn);
 139                     if (m == null) {
 140                         ModuleReference mref = finder.find(mn).get();
 141                         m = toModule(mref);
 142                     }
 143                     return m;
 144                 }));
 145         Profile.init(systemModules);
 146     }
 147 
 148     private void addModuleReference(ModuleReference mref) {
 149         Module module = toModule(mref);
 150         nameToModule.put(mref.descriptor().name(), module);
 151         mref.descriptor().packages()
 152             .forEach(pn -> packageToModule.putIfAbsent(pn, module));
 153     }
 154 
 155     private void addPackagesInUnnamedModule(Archive archive) {
 156         archive.reader().entries().stream()
 157                .filter(e -> e.endsWith(".class") && !e.equals(MODULE_INFO))
 158                .map(this::toPackageName)
 159                .distinct()
 160                .forEach(pn -> packageToUnnamedModule
 161                    .computeIfAbsent(pn, _n -> new ArrayList<>()).add(archive));
 162     }
 163 
 164     private String toPackageName(String name) {
 165         int i = name.lastIndexOf('/');
 166         return i > 0 ? name.replace('/', '.').substring(0, i) : "";
 167     }
 168 
 169     public Optional<Module> findModule(String name) {
 170         Objects.requireNonNull(name);
 171         Module m = nameToModule.get(name);
 172         return m!= null ? Optional.of(m) : Optional.empty();
 173 
 174     }
 175 
 176     public Optional<ModuleDescriptor> findModuleDescriptor(String name) {
 177         Objects.requireNonNull(name);
 178         Module m = nameToModule.get(name);
 179         return m!= null ? Optional.of(m.descriptor()) : Optional.empty();
 180     }
 181 
 182     public static boolean isToken(String name) {
 183         return ALL_MODULE_PATH.equals(name) ||
 184                ALL_DEFAULT.equals(name) ||
 185                ALL_SYSTEM.equals(name);
 186     }
 187 
 188     /**
 189      * Returns the list of packages that split between resolved module and
 190      * unnamed module
 191      */
 192     public Map<String, Set<String>> splitPackages() {
 193         Set<String> splitPkgs = packageToModule.keySet().stream()
 194                                        .filter(packageToUnnamedModule::containsKey)
 195                                        .collect(toSet());
 196         if (splitPkgs.isEmpty())
 197             return Collections.emptyMap();
 198 
 199         return splitPkgs.stream().collect(toMap(Function.identity(), (pn) -> {
 200             Set<String> sources = new LinkedHashSet<>();
 201             sources.add(packageToModule.get(pn).getModule().location().toString());
 202             packageToUnnamedModule.get(pn).stream()
 203                 .map(Archive::getPathName)
 204                 .forEach(sources::add);
 205             return sources;
 206         }));
 207     }
 208 
 209     /**
 210      * Returns an optional archive containing the given Location
 211      */
 212     public Optional<Archive> findClass(Dependency.Location location) {
 213         String name = location.getName();
 214         int i = name.lastIndexOf('/');
 215         String pn = i > 0 ? name.substring(0, i).replace('/', '.') : "";
 216         Archive archive = packageToModule.get(pn);
 217         if (archive != null) {
 218             return archive.contains(name + ".class")
 219                         ? Optional.of(archive)
 220                         : Optional.empty();
 221         }
 222 
 223         if (packageToUnnamedModule.containsKey(pn)) {
 224             return packageToUnnamedModule.get(pn).stream()
 225                     .filter(a -> a.contains(name + ".class"))
 226                     .findFirst();
 227         }
 228         return Optional.empty();
 229     }
 230 
 231     /**
 232      * Returns the list of Modules that can be found in the specified
 233      * module paths.
 234      */
 235     public Map<String, Module> getModules() {
 236         return nameToModule;
 237     }
 238 
 239     /**
 240      * Returns Configuration with the given roots
 241      */
 242     public Configuration resolve(Set<String> roots) {
 243         if (roots.isEmpty())
 244             throw new IllegalArgumentException("empty roots");
 245 
 246         return Configuration.empty()
 247                     .resolve(finder, ModuleFinder.of(), roots);
 248     }
 249 
 250     public List<Archive> classPathArchives() {
 251         return classpathArchives;
 252     }
 253 
 254     public List<Archive> initialArchives() {
 255         return initialArchives;
 256     }
 257 
 258     public Set<Module> rootModules() {
 259         return rootModules;
 260     }
 261 
 262     public Module toModule(ModuleReference mref) {
 263         try {
 264             String mn = mref.descriptor().name();
 265             URI location = mref.location().orElseThrow(FileNotFoundException::new);
 266             ModuleDescriptor md = mref.descriptor();
 267             // is this module from the system module path?
 268             URI loc = system.find(mn).flatMap(ModuleReference::location).orElse(null);
 269             boolean isSystem = location.equals(loc);
 270 
 271             final ClassFileReader reader;
 272             if (location.getScheme().equals("jrt")) {
 273                 reader = system.getClassReader(mn);
 274             } else {
 275                 reader = ClassFileReader.newInstance(Paths.get(location), version);
 276             }
 277             Module.Builder builder = new Module.Builder(md, isSystem);
 278             builder.classes(reader);
 279             builder.location(location);
 280 
 281             return builder.build();
 282         } catch (IOException e) {
 283             throw new UncheckedIOException(e);
 284         }
 285     }
 286 
 287     public Runtime.Version getVersion() {
 288         return version;
 289     }
 290 
 291     /*
 292      * Close all archives e.g. JarFile
 293      */
 294     @Override
 295     public void close() throws IOException {
 296         for (Archive archive : initialArchives)
 297             archive.close();
 298         for (Archive archive : classpathArchives)
 299             archive.close();
 300         for (Module module : nameToModule.values())
 301             module.close();
 302     }
 303 
 304     static class SystemModuleFinder implements ModuleFinder {
 305         private static final String JAVA_HOME = System.getProperty("java.home");
 306 
 307         private final FileSystem fileSystem;
 308         private final Path root;
 309         private final Map<String, ModuleReference> systemModules;
 310 
 311         SystemModuleFinder() {
 312             if (Files.isRegularFile(Paths.get(JAVA_HOME, "lib", "modules"))) {
 313                 // jrt file system
 314                 this.fileSystem = FileSystems.getFileSystem(URI.create("jrt:/"));
 315                 this.root = fileSystem.getPath("/modules");
 316                 this.systemModules = walk(root);
 317             } else {
 318                 // exploded image
 319                 this.fileSystem = FileSystems.getDefault();
 320                 root = Paths.get(JAVA_HOME, "modules");
 321                 this.systemModules = ModuleFinder.ofSystem().findAll().stream()
 322                     .collect(toMap(mref -> mref.descriptor().name(), Function.identity()));
 323             }
 324         }
 325 
 326         SystemModuleFinder(String javaHome) throws IOException {
 327             if (javaHome == null) {
 328                 // --system none
 329                 this.fileSystem = null;
 330                 this.root = null;
 331                 this.systemModules = Collections.emptyMap();
 332             } else {
 333                 if (!Files.isRegularFile(Paths.get(javaHome, "lib", "modules")))
 334                     throw new IllegalArgumentException("Invalid java.home: " + javaHome);
 335 
 336                 // alternate java.home
 337                 Map<String, String> env = new HashMap<>();
 338                 env.put("java.home", javaHome);
 339                 // a remote run-time image
 340                 this.fileSystem = FileSystems.newFileSystem(URI.create("jrt:/"), env);
 341                 this.root = fileSystem.getPath("/modules");
 342                 this.systemModules = walk(root);
 343             }
 344         }
 345 
 346         private Map<String, ModuleReference> walk(Path root) {
 347             try (Stream<Path> stream = Files.walk(root, 1)) {
 348                 return stream.filter(path -> !path.equals(root))
 349                              .map(this::toModuleReference)
 350                              .collect(toMap(mref -> mref.descriptor().name(),
 351                                             Function.identity()));
 352             } catch (IOException e) {
 353                 throw new UncheckedIOException(e);
 354             }
 355         }
 356 
 357         private ModuleReference toModuleReference(Path path) {
 358             Path minfo = path.resolve(MODULE_INFO);
 359             try (InputStream in = Files.newInputStream(minfo);
 360                  BufferedInputStream bin = new BufferedInputStream(in)) {
 361 
 362                 ModuleDescriptor descriptor = dropHashes(ModuleDescriptor.read(bin));
 363                 String mn = descriptor.name();
 364                 URI uri = URI.create("jrt:/" + path.getFileName().toString());
 365                 Supplier<ModuleReader> readerSupplier = () -> new ModuleReader() {
 366                     @Override
 367                     public Optional<URI> find(String name) throws IOException {
 368                         return name.equals(mn)
 369                             ? Optional.of(uri) : Optional.empty();
 370                     }
 371 
 372                     @Override
 373                     public Stream<String> list() {
 374                         return Stream.empty();
 375                     }
 376 
 377                     @Override
 378                     public void close() {
 379                     }
 380                 };
 381 
 382                 return new ModuleReference(descriptor, uri) {
 383                     @Override
 384                     public ModuleReader open() {
 385                         return readerSupplier.get();
 386                     }
 387                 };
 388             } catch (IOException e) {
 389                 throw new UncheckedIOException(e);
 390             }
 391         }
 392 
 393         private ModuleDescriptor dropHashes(ModuleDescriptor md) {
 394             ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(md.name());
 395             md.requires().forEach(builder::requires);
 396             md.exports().forEach(builder::exports);
 397             md.opens().forEach(builder::opens);
 398             md.provides().stream().forEach(builder::provides);
 399             md.uses().stream().forEach(builder::uses);
 400             builder.packages(md.packages());
 401             return builder.build();
 402         }
 403 
 404         @Override
 405         public Set<ModuleReference> findAll() {
 406             return systemModules.values().stream().collect(toSet());
 407         }
 408 
 409         @Override
 410         public Optional<ModuleReference> find(String mn) {
 411             return systemModules.containsKey(mn)
 412                     ? Optional.of(systemModules.get(mn)) : Optional.empty();
 413         }
 414 
 415         public Stream<String> moduleNames() {
 416             return systemModules.values().stream()
 417                 .map(mref -> mref.descriptor().name());
 418         }
 419 
 420         public ClassFileReader getClassReader(String modulename) throws IOException {
 421             Path mp = root.resolve(modulename);
 422             if (Files.exists(mp) && Files.isDirectory(mp)) {
 423                 return ClassFileReader.newInstance(fileSystem, mp);
 424             } else {
 425                 throw new FileNotFoundException(mp.toString());
 426             }
 427         }
 428 
 429         public Set<String> defaultSystemRoots() {
 430             return systemModules.values().stream()
 431                 .map(ModuleReference::descriptor)
 432                 .filter(descriptor -> descriptor.exports()
 433                         .stream()
 434                         .filter(e -> !e.isQualified())
 435                         .findAny()
 436                         .isPresent())
 437                 .map(ModuleDescriptor::name)
 438                 .collect(Collectors.toSet());
 439         }
 440     }
 441 
 442     public static class Builder {
 443 
 444         final SystemModuleFinder systemModulePath;
 445         final Set<String> rootModules = new HashSet<>();
 446         final List<Archive> initialArchives = new ArrayList<>();
 447         final List<Path> paths = new ArrayList<>();
 448         final List<Path> classPaths = new ArrayList<>();
 449         final Set<String> tokens = new HashSet<>();
 450 
 451         ModuleFinder upgradeModulePath;
 452         ModuleFinder appModulePath;
 453         Runtime.Version version;
 454 
 455         public Builder() {
 456             this.systemModulePath = new SystemModuleFinder();
 457         }
 458 
 459         public Builder(String javaHome) throws IOException {
 460             this.systemModulePath = SystemModuleFinder.JAVA_HOME.equals(javaHome)
 461                 ? new SystemModuleFinder()
 462                 : new SystemModuleFinder(javaHome);
 463         }
 464 
 465         public Builder upgradeModulePath(String upgradeModulePath) {
 466             this.upgradeModulePath = createModulePathFinder(upgradeModulePath);
 467             return this;
 468         }
 469 
 470         public Builder appModulePath(String modulePath) {
 471             this.appModulePath = createModulePathFinder(modulePath);
 472             return this;
 473         }
 474 
 475         public Builder addmods(Set<String> addmods) {
 476             for (String mn : addmods) {
 477                 if (isToken(mn)) {
 478                     tokens.add(mn);
 479                 } else {
 480                     rootModules.add(mn);
 481                 }
 482             }
 483             return this;
 484         }
 485 
 486         public Builder multiRelease(Runtime.Version version) {
 487             this.version = version;
 488             return this;
 489         }
 490 
 491         public Builder addRoot(Path path) {
 492             Archive archive = Archive.getInstance(path, version);
 493             if (archive.contains(MODULE_INFO)) {
 494                 paths.add(path);
 495             } else {
 496                 initialArchives.add(archive);
 497             }
 498             return this;
 499         }
 500 
 501         public Builder addClassPath(String classPath) {
 502             this.classPaths.addAll(getClassPaths(classPath));
 503             return this;
 504         }
 505 
 506         public JdepsConfiguration build() throws  IOException {
 507             ModuleFinder finder = systemModulePath;
 508             if (upgradeModulePath != null) {
 509                 finder = ModuleFinder.compose(upgradeModulePath, systemModulePath);
 510             }
 511             if (appModulePath != null) {
 512                 finder = ModuleFinder.compose(finder, appModulePath);
 513             }
 514             if (!paths.isEmpty()) {
 515                 ModuleFinder otherModulePath = ModuleFinder.of(paths.toArray(new Path[0]));
 516 
 517                 finder = ModuleFinder.compose(finder, otherModulePath);
 518                 // add modules specified on command-line (convenience) as root set
 519                 otherModulePath.findAll().stream()
 520                         .map(mref -> mref.descriptor().name())
 521                         .forEach(rootModules::add);
 522             }
 523 








 524             // no archive is specified for analysis
 525             // add all system modules as root if --add-modules ALL-SYSTEM is specified
 526             if (tokens.contains(ALL_SYSTEM) && rootModules.isEmpty() &&
 527                     initialArchives.isEmpty() && classPaths.isEmpty()) {
 528                 systemModulePath.findAll()
 529                     .stream()
 530                     .map(mref -> mref.descriptor().name())
 531                     .forEach(rootModules::add);
 532             }
 533 
 534             // add all modules on app module path as roots if ALL-MODULE-PATH is specified
 535             if ((tokens.contains(ALL_MODULE_PATH)) && appModulePath != null) {
 536                 appModulePath.findAll().stream()
 537                     .map(mref -> mref.descriptor().name())
 538                     .forEach(rootModules::add);
 539             }
 540 
 541 
 542             // build root set for module resolution
 543             Set<String> mods = new HashSet<>(rootModules);
 544             // if archives are specified for analysis, then consider as unnamed module
 545             boolean unnamed = !initialArchives.isEmpty() || !classPaths.isEmpty();
 546             if (tokens.contains(ALL_DEFAULT)) {
 547                 mods.addAll(systemModulePath.defaultSystemRoots());
 548             } else if (tokens.contains(ALL_SYSTEM) || unnamed) {
 549                 // resolve all system modules as unnamed module may reference any class
 550                 systemModulePath.findAll().stream()
 551                     .map(mref -> mref.descriptor().name())
 552                     .forEach(mods::add);
 553             }
 554             if (unnamed && appModulePath != null) {
 555                 // resolve all modules on module path as unnamed module may reference any class
 556                 appModulePath.findAll().stream()
 557                     .map(mref -> mref.descriptor().name())
 558                     .forEach(mods::add);
 559             }
 560 
 561             // resolve the module graph
 562             Configuration config = Configuration.empty().resolve(finder, ModuleFinder.of(), mods);
 563             return new JdepsConfiguration(config,
 564                                           systemModulePath,
 565                                           finder,
 566                                           rootModules,
 567                                           classPaths,
 568                                           initialArchives,

 569                                           version);
 570         }
 571 
 572         private static ModuleFinder createModulePathFinder(String mpaths) {
 573             if (mpaths == null) {
 574                 return null;
 575             } else {
 576                 String[] dirs = mpaths.split(File.pathSeparator);
 577                 Path[] paths = new Path[dirs.length];
 578                 int i = 0;
 579                 for (String dir : dirs) {
 580                     paths[i++] = Paths.get(dir);
 581                 }
 582                 return ModuleFinder.of(paths);
 583             }
 584         }
 585 
 586         /*
 587          * Returns the list of Archive specified in cpaths and not included
 588          * initialArchives
 589          */
 590         private List<Path> getClassPaths(String cpaths) {
 591             if (cpaths.isEmpty()) {
 592                 return Collections.emptyList();
 593             }
 594             List<Path> paths = new ArrayList<>();
 595             for (String p : cpaths.split(File.pathSeparator)) {
 596                 if (p.length() > 0) {
 597                     // wildcard to parse all JAR files e.g. -classpath dir/*
 598                     int i = p.lastIndexOf(".*");
 599                     if (i > 0) {
 600                         Path dir = Paths.get(p.substring(0, i));
 601                         try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, "*.jar")) {
 602                             for (Path entry : stream) {
 603                                 paths.add(entry);
 604                             }
 605                         } catch (IOException e) {
 606                             throw new UncheckedIOException(e);
 607                         }
 608                     } else {
 609                         paths.add(Paths.get(p));
 610                     }
 611                 }
 612             }
 613             return paths;
 614         }
 615     }
 616 
 617 }
--- EOF ---