stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8157598: ModuleReader find returns incorrect URI when modular JAR is a multi-release JAR

Browse Source 
Reviewed-by: chegar, mchung
This commit is contained in:
Alan Bateman 2016-05-24 11:31:25 +01:00
parent e549e87431
commit fe609fd3cb
3 changed files with 243 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
jdk/src/java.base/share/classes/java/lang/module/ModuleReferences.java
View File

@ -220,10 +220,10 @@ class ModuleReferences {
Optional<URI> implFind(String name) throws IOException {
JarEntry je = getEntry(name);
if (je != null) {
if (jf.isMultiRelease())
name = SharedSecrets.javaUtilJarAccess().getRealName(jf, je);
String encodedPath = ParseUtil.encodePath(name, false);
String uris = "jar:" + uri + "!/" + encodedPath;
if (jf.isMultiRelease())
uris += "#runtime";
return Optional.of(URI.create(uris));
} else {
return Optional.empty();

216
jdk/test/java/lang/module/ModuleReader/MultiReleaseJarTest.java Normal file
View File

@ -0,0 +1,216 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @library /lib/testlibrary
* @modules java.base/jdk.internal.module
* @build MultiReleaseJarTest JarUtils
* @run testng MultiReleaseJarTest
* @run testng/othervm -Djdk.util.jar.enableMultiRelease=false MultiReleaseJarTest
* @summary Basic test of ModuleReader with a modular JAR that is also a
* multi-release JAR
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.module.ModuleDescriptor;
import java.lang.module.ModuleFinder;
import java.lang.module.ModuleReader;
import java.lang.module.ModuleReference;
import java.net.URI;
import java.net.URLConnection;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Optional;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import java.util.stream.Collectors;
import jdk.internal.module.ModuleInfoWriter;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
/**
* Exercises ModuleReader with a modular JAR containing the following files:
*
* <pre>{@code
* module-info.class
* META-INF/versions/<version>/module.class
* }</pre>
*
* The module-info.class in the top-level directory is the binary form of:
* <pre>{@code
* module jdk.test {
* requires java.base;
* }
* }</pre>
*
* The module-info.class in the versioned section is the binary form of:
* <pre>{@code
* module jdk.test {
* requires java.base;
* requires jdk.unsupported;
* }
* }</pre>
*/
@Test
public class MultiReleaseJarTest {
// Java SE/JDK major release
private static final int RELEASE = Runtime.version().major();
// the name of the test module
private static final String MODULE_NAME = "jdk.test";
private static final String MODULE_INFO_CLASS = "module-info.class";
/**
* Uses the ModuleFinder API to locate the module packaged as a modular
* and mutli-release JAR and then creates a ModuleReader to access the
* contents of the module.
*/
public void testMultiReleaseJar() throws IOException {
// are multi-release JARs enabled?
String s = System.getProperty("jdk.util.jar.enableMultiRelease");
boolean multiRelease = (s == null || Boolean.parseBoolean(s));
// create the multi-release modular JAR
Path jarfile = createJarFile();
// find the module
ModuleFinder finder = ModuleFinder.of(jarfile);
Optional<ModuleReference> omref = finder.find(MODULE_NAME);
assertTrue((omref.isPresent()));
ModuleReference mref = omref.get();
// test that correct module-info.class was read
checkDescriptor(mref.descriptor(), multiRelease);
// test ModuleReader
try (ModuleReader reader = mref.open()) {
// open resource
Optional<InputStream> oin = reader.open(MODULE_INFO_CLASS);
assertTrue(oin.isPresent());
try (InputStream in = oin.get()) {
checkDescriptor(ModuleDescriptor.read(in), multiRelease);
}
// read resource
Optional<ByteBuffer> obb = reader.read(MODULE_INFO_CLASS);
assertTrue(obb.isPresent());
ByteBuffer bb = obb.get();
try {
checkDescriptor(ModuleDescriptor.read(bb), multiRelease);
} finally {
reader.release(bb);
}
// find resource
Optional<URI> ouri = reader.find(MODULE_INFO_CLASS);
assertTrue(ouri.isPresent());
URI uri = ouri.get();
String expectedTail = "!/";
if (multiRelease)
expectedTail += "META-INF/versions/" + RELEASE + "/";
expectedTail += MODULE_INFO_CLASS;
assertTrue(uri.toString().endsWith(expectedTail));
URLConnection uc = uri.toURL().openConnection();
uc.setUseCaches(false);
try (InputStream in = uc.getInputStream()) {
checkDescriptor(ModuleDescriptor.read(in), multiRelease);
}
}
}
/**
* Checks that the module descriptor is the expected module descriptor.
* When the multi release JAR feature is enabled then the module
* descriptor is expected to have been read from the versioned section
* of the JAR file.
*/
private void checkDescriptor(ModuleDescriptor descriptor, boolean multiRelease) {
Set<String> requires = descriptor.requires().stream()
.map(ModuleDescriptor.Requires::name)
.collect(Collectors.toSet());
assertTrue(requires.contains("java.base"));
assertTrue(requires.contains("jdk.unsupported") == multiRelease);
}
/**
* Creates the modular JAR for the test, returning the Path to the JAR file.
*/
private Path createJarFile() throws IOException {
// module descriptor for top-level directory
ModuleDescriptor descriptor1
= new ModuleDescriptor.Builder(MODULE_NAME)
.requires("java.base")
.build();
// module descriptor for versioned section
ModuleDescriptor descriptor2
= new ModuleDescriptor.Builder(MODULE_NAME)
.requires("java.base")
.requires("jdk.unsupported")
.build();
Path top = Paths.get(MODULE_NAME);
Files.createDirectories(top);
Path mi1 = Paths.get(MODULE_INFO_CLASS);
try (OutputStream out = Files.newOutputStream(top.resolve(mi1))) {
ModuleInfoWriter.write(descriptor1, out);
}
Path vdir = Paths.get("META-INF", "versions", Integer.toString(RELEASE));
Files.createDirectories(top.resolve(vdir));
Path mi2 = vdir.resolve(MODULE_INFO_CLASS);
try (OutputStream out = Files.newOutputStream(top.resolve(mi2))) {
ModuleInfoWriter.write(descriptor2, out);
}
Manifest man = new Manifest();
Attributes attrs = man.getMainAttributes();
attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0");
attrs.put(Attributes.Name.MULTI_RELEASE, "true");
Path jarfile = Paths.get(MODULE_NAME + ".jar");
JarUtils.createJarFile(jarfile, man, top, mi1, mi2);
return jarfile;
}
}

27
jdk/test/lib/testlibrary/JarUtils.java
View File

@ -35,6 +35,7 @@ import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@ -49,12 +50,12 @@ public final class JarUtils {
/**
* Creates a JAR file.
*
* Equivalent to {@code jar cf <jarfile> -C <dir> file...}
* Equivalent to {@code jar cfm <jarfile> <manifest> -C <dir> file...}
*
* The input files are resolved against the given directory. Any input
* files that are directories are processed recursively.
*/
public static void createJarFile(Path jarfile, Path dir, Path... file)
public static void createJarFile(Path jarfile, Manifest man, Path dir, Path... file)
throws IOException
{
// create the target directory
@ -73,14 +74,36 @@ public final class JarUtils {
try (OutputStream out = Files.newOutputStream(jarfile);
JarOutputStream jos = new JarOutputStream(out))
{
if (man != null) {
JarEntry je = new JarEntry(JarFile.MANIFEST_NAME);
jos.putNextEntry(je);
man.write(jos);
jos.closeEntry();
}
for (Path entry : entries) {
String name = toJarEntryName(entry);
jos.putNextEntry(new JarEntry(name));
Files.copy(dir.resolve(entry), jos);
jos.closeEntry();
}
}
}
/**
* Creates a JAR file.
*
* Equivalent to {@code jar cf <jarfile> -C <dir> file...}
*
* The input files are resolved against the given directory. Any input
* files that are directories are processed recursively.
*/
public static void createJarFile(Path jarfile, Path dir, Path... file)
throws IOException
{
createJarFile(jarfile, null, dir, file);
}
/**
* Creates a JAR file.
*