jdk-sandbox: comparison jdk/src/java.base/share/classes/java/lang/module/ModulePath.java

equal deleted inserted replaced

-:07e906f1a20b
+:b90ad1de93ea
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.UncheckedIOException;
 import java.lang.module.ModuleDescriptor.Requires;
+import java.net.URI;
 import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.jar.JarFile;
 import java.util.jar.Manifest;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 import jdk.internal.jmod.JmodFile;
 import jdk.internal.jmod.JmodFile.Section;
-import jdk.internal.module.ConfigurableModuleFinder;
+import jdk.internal.module.Checks;
 import jdk.internal.perf.PerfCounter;
+import jdk.internal.util.jar.VersionedStream;
 /**
 * A {@code ModuleFinder} that locates modules on the file system by searching
 * a sequence of directories or packaged modules.
 *
-* The {@code ModuleFinder} can be configured to work in either the run-time
+* The {@code ModuleFinder} can be created to work in either the run-time
 * or link-time phases. In both cases it locates modular JAR and exploded
-* modules. When configured for link-time then it additionally locates
+* modules. When created for link-time then it additionally locates
 * modules in JMOD files.
 */
-class ModulePath implements ConfigurableModuleFinder {
+class ModulePath implements ModuleFinder {
 private static final String MODULE_INFO = "module-info.class";
+// the version to use for multi-release modular JARs
+private final Runtime.Version releaseVersion;
+// true for the link phase (supports modules packaged in JMOD format)
+private final boolean isLinkPhase;
 // the entries on this module path
 private final Path[] entries;
 private int next;
-// true if in the link phase
-private boolean isLinkPhase;
 // map of module name to module reference map for modules already located
 private final Map<String, ModuleReference> cachedModules = new HashMap<>();
-ModulePath(Path... entries) {
+ModulePath(Runtime.Version version, boolean isLinkPhase, Path... entries) {
+this.releaseVersion = version;
+this.isLinkPhase = isLinkPhase;
 this.entries = entries.clone();
 for (Path entry : this.entries) {
 Objects.requireNonNull(entry);
 }
 }
-@Override
+ModulePath(Path... entries) {
-public void configurePhase(Phase phase) {
+this(JarFile.runtimeVersion(), false, entries);
-isLinkPhase = (phase == Phase.LINK_TIME);
 }
 @Override
 public Optional<ModuleReference> find(String name) {
 Objects.requireNonNull(name);
 // module found
 if (mref != null) {
 // can have at most one version of a module in the directory
 String name = mref.descriptor().name();
-if (nameToReference.put(name, mref) != null) {
+ModuleReference previous = nameToReference.put(name, mref);
+if (previous != null) {
+String fn1 = fileName(mref);
+String fn2 = fileName(previous);
 throw new FindException("Two versions of module "
-+ name + " found in " + dir);
++ name + " found in " + dir
++ " (" + fn1 + " and " + fn2 + ")");
 }
 }
 }
 }
 throw new FindException("Error reading module: " + entry, e);
 }
 }
+/**
+* Returns a string with the file name of the module if possible.
+* If the module location is not a file URI then return the URI
+* as a string.
+*/
+private String fileName(ModuleReference mref) {
+URI uri = mref.location().orElse(null);
+if (uri != null) {
+if (uri.getScheme().equalsIgnoreCase("file")) {
+Path file = Paths.get(uri);
+return file.getFileName().toString();
+} else {
+return uri.toString();
+}
+} else {
+return "<unknown>";
+}
+}
 // -- jmod files --
 private Set<String> jmodPackages(JmodFile jf) {
 return jf.stream()
 .filter(e -> e.section() == Section.CLASSES)
 .map(JmodFile.Entry::name)
 .map(this::toPackageName)
-.filter(pkg -> pkg.length() > 0) // module-info
+.flatMap(Optional::stream)
 .collect(Collectors.toSet());
 }
 /**
 * Returns a {@code ModuleReference} to a module in jmod file on the
 // -- JAR files --
 private static final String SERVICES_PREFIX = "META-INF/services/";
 /**
-* Returns a container with the service type corresponding to the name of
+* Returns the service type corresponding to the name of a services
-* a services configuration file.
+* configuration file if it is a valid Java identifier.
 *
 * For example, if called with "META-INF/services/p.S" then this method
 * returns a container with the value "p.S".
 */
 private Optional<String> toServiceName(String cf) {
 int index = cf.lastIndexOf("/") + 1;
 if (index < cf.length()) {
 String prefix = cf.substring(0, index);
 if (prefix.equals(SERVICES_PREFIX)) {
 String sn = cf.substring(index);
-return Optional.of(sn);
+if (Checks.isJavaIdentifier(sn))
+return Optional.of(sn);
 }
 }
 return Optional.empty();
 }
 .automatic()
 .requires(Set.of(Requires.Modifier.MANDATED), "java.base");
 if (vs != null)
 builder.version(vs);
-// scan the entries in the JAR file to locate the .class and service
+// scan the names of the entries in the JAR file
-// configuration file
+Map<Boolean, Set<String>> map = VersionedStream.stream(jf)
-Map<Boolean, Set<String>> map =
+.filter(e -> !e.isDirectory())
-versionedStream(jf)
+.map(JarEntry::getName)
-.map(JarEntry::getName)
+.collect(Collectors.partitioningBy(e -> e.startsWith(SERVICES_PREFIX),
-.filter(s -> (s.endsWith(".class") ^ s.startsWith(SERVICES_PREFIX)))
+Collectors.toSet()));
-.collect(Collectors.partitioningBy(s -> s.endsWith(".class"),
-Collectors.toSet()));
+Set<String> resources = map.get(Boolean.FALSE);
-Set<String> classFiles = map.get(Boolean.TRUE);
+Set<String> configFiles = map.get(Boolean.TRUE);
-Set<String> configFiles = map.get(Boolean.FALSE);
 // all packages are exported
-classFiles.stream()
+resources.stream()
-.map(c -> toPackageName(c))
+.map(this::toPackageName)
-.distinct()
+.flatMap(Optional::stream)
-.forEach(builder::exports);
+.distinct()
+.forEach(builder::exports);
 // map names of service configuration files to service names
 Set<String> serviceNames = configFiles.stream()
 .map(this::toServiceName)
 .flatMap(Optional::stream)
 .collect(Collectors.toSet());
 // parse each service configuration file
 for (String sn : serviceNames) {
 JarEntry entry = jf.getJarEntry(SERVICES_PREFIX + sn);
 Set<String> providerClasses = new LinkedHashSet<>();
 mn = Patterns.TRAILING_DOTS.matcher(mn).replaceAll("");
 return mn;
 }
-private Stream<JarEntry> versionedStream(JarFile jf) {
-if (jf.isMultiRelease()) {
-// a stream of JarEntries whose names are base names and whose
-// contents are from the corresponding versioned entries in
-// a multi-release jar file
-return jf.stream().map(JarEntry::getName)
-.filter(name -> !name.startsWith("META-INF/versions/"))
-.map(jf::getJarEntry);
-} else {
-return jf.stream();
-}
-}
 private Set<String> jarPackages(JarFile jf) {
-return versionedStream(jf)
+return VersionedStream.stream(jf)
-.filter(e -> e.getName().endsWith(".class"))
+.filter(e -> !e.isDirectory())
-.map(e -> toPackageName(e.getName()))
+.map(JarEntry::getName)
-.filter(pkg -> pkg.length() > 0)   // module-info
+.map(this::toPackageName)
-.collect(Collectors.toSet());
+.flatMap(Optional::stream)
+.collect(Collectors.toSet());
 }
 /**
 * Returns a {@code ModuleReference} to a module in modular JAR file on
 * the file system.
 */
 private ModuleReference readJar(Path file) throws IOException {
 try (JarFile jf = new JarFile(file.toFile(),
 true,               // verify
 ZipFile.OPEN_READ,
-JarFile.runtimeVersion()))
+releaseVersion))
 {
 ModuleDescriptor md;
 JarEntry entry = jf.getJarEntry(MODULE_INFO);
 if (entry == null) {
 // -- exploded directories --
 private Set<String> explodedPackages(Path dir) {
 try {
 return Files.find(dir, Integer.MAX_VALUE,
-((path, attrs) -> attrs.isRegularFile() &&
+((path, attrs) -> attrs.isRegularFile()))
-path.toString().endsWith(".class")))
+.map(path -> dir.relativize(path))
-.map(path -> toPackageName(dir.relativize(path)))
+.map(this::toPackageName)
-.filter(pkg -> pkg.length() > 0)   // module-info
+.flatMap(Optional::stream)
 .collect(Collectors.toSet());
 } catch (IOException x) {
 throw new UncheckedIOException(x);
 }
 }
 return null;
 }
 return ModuleReferences.newExplodedModule(md, dir);
 }
+/**
-//
+* Maps the name of an entry in a JAR or ZIP file to a package name.
+*
-// p/q/T.class => p.q
+* @throws IllegalArgumentException if the name is a class file in
-private String toPackageName(String cn) {
+*         the top-level directory of the JAR/ZIP file (and it's
-assert cn.endsWith(".class");
+*         not module-info.class)
-int start = 0;
+*/
-int index = cn.lastIndexOf("/");
+private Optional<String> toPackageName(String name) {
-if (index > start) {
+assert !name.endsWith("/");
-return cn.substring(start, index).replace('/', '.');
+int index = name.lastIndexOf("/");
+if (index == -1) {
+if (name.endsWith(".class") && !name.equals(MODULE_INFO)) {
+throw new IllegalArgumentException(name
++ " found in top-level directory:"
++ " (unnamed package not allowed in module)");
+}
+return Optional.empty();
+}
+String pn = name.substring(0, index).replace('/', '.');
+if (Checks.isJavaIdentifier(pn)) {
+return Optional.of(pn);
 } else {
-return "";
+// not a valid package name
-}
+return Optional.empty();
 }
+}
-private String toPackageName(Path path) {
-String name = path.toString();
+/**
-assert name.endsWith(".class");
+* Maps the relative path of an entry in an exploded module to a package
-int index = name.lastIndexOf(File.separatorChar);
+* name.
-if (index != -1) {
+*
-return name.substring(0, index).replace(File.separatorChar, '.');
+* @throws IllegalArgumentException if the name is a class file in
+*         the top-level directory (and it's not module-info.class)
+*/
+private Optional<String> toPackageName(Path file) {
+assert file.getRoot() == null;
+Path parent = file.getParent();
+if (parent == null) {
+String name = file.toString();
+if (name.endsWith(".class") && !name.equals(MODULE_INFO)) {
+throw new IllegalArgumentException(name
++ " found in in top-level directory"
++ " (unnamed package not allowed in module)");
+}
+return Optional.empty();
+}
+String pn = parent.toString().replace(File.separatorChar, '.');
+if (Checks.isJavaIdentifier(pn)) {
+return Optional.of(pn);
 } else {
-return "";
+// not a valid package name
+return Optional.empty();
 }
 }
 private static final PerfCounter scanTime
 = PerfCounter.newPerfCounter("jdk.module.finder.modulepath.scanTime");

changeset 41817	b90ad1de93ea
parent 41352	f9844bad9052
child 42338	a60f280f803c