274 lines
9.8 KiB
Java
274 lines
9.8 KiB
Java
/*
|
|
* Copyright (c) 2016, 2018, 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
|
|
* @bug 8157068 8177844
|
|
* @summary Patch java.base and user module with ModuleHashes attribute
|
|
* @library /test/lib
|
|
* @modules jdk.compiler
|
|
* @build jdk.test.lib.compiler.CompilerUtils
|
|
* jdk.test.lib.util.FileUtils
|
|
* jdk.test.lib.Platform
|
|
* @run testng PatchSystemModules
|
|
*/
|
|
|
|
import java.io.File;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.stream.Stream;
|
|
|
|
import jdk.test.lib.compiler.CompilerUtils;
|
|
import jdk.test.lib.util.FileUtils;
|
|
import jdk.test.lib.JDKToolFinder;
|
|
import org.testng.annotations.BeforeTest;
|
|
import org.testng.annotations.Test;
|
|
|
|
import static jdk.test.lib.process.ProcessTools.executeCommand;
|
|
import static org.testng.Assert.*;
|
|
|
|
public class PatchSystemModules {
|
|
private static final String JAVA_HOME = System.getProperty("java.home");
|
|
|
|
private static final Path TEST_SRC = Paths.get(System.getProperty("test.src"));
|
|
|
|
private static final Path JMODS = Paths.get(JAVA_HOME, "jmods");
|
|
private static final Path MODS_DIR = Paths.get("mods");
|
|
private static final Path JARS_DIR = Paths.get("jars");
|
|
private static final Path PATCH_DIR = Paths.get("patches");
|
|
private static final Path IMAGE = Paths.get("image");
|
|
private static final Path NEW_M1_JAR = JARS_DIR.resolve("new_m1.jar");
|
|
|
|
private static final String JAVA_BASE = "java.base";
|
|
private final String[] modules = new String[] { "m1", "m2" };
|
|
|
|
@BeforeTest
|
|
private void setup() throws Throwable {
|
|
Path src = TEST_SRC.resolve("src");
|
|
Path src1 = TEST_SRC.resolve("src1");
|
|
|
|
for (String name : modules) {
|
|
assertTrue(CompilerUtils.compile(src.resolve(name),
|
|
MODS_DIR,
|
|
"--module-source-path", src.toString()));
|
|
}
|
|
|
|
// compile patched source
|
|
String patchDir = src1.resolve(JAVA_BASE).toString();
|
|
assertTrue(CompilerUtils.compile(src1.resolve(JAVA_BASE),
|
|
PATCH_DIR.resolve(JAVA_BASE),
|
|
"--patch-module", "java.base=" + patchDir));
|
|
assertTrue(CompilerUtils.compile(src1.resolve("m2"),
|
|
PATCH_DIR.resolve("m2")));
|
|
|
|
createJars();
|
|
|
|
// create an image with only m1 and m2
|
|
if (Files.exists(JMODS)) {
|
|
// create an image with m1,m2
|
|
createImage();
|
|
}
|
|
|
|
// compile a different version of m1
|
|
Path tmp = Paths.get("tmp");
|
|
assertTrue(CompilerUtils.compile(src1.resolve("m1"), tmp,
|
|
"--module-path", MODS_DIR.toString(),
|
|
"--module-source-path", src1.toString()));
|
|
|
|
// package new_m1.jar
|
|
jar("--create",
|
|
"--file=" + NEW_M1_JAR.toString(),
|
|
"-C", tmp.resolve("m1").toString(), ".");
|
|
}
|
|
|
|
/*
|
|
* Test patching system module and user module on module path
|
|
*/
|
|
@Test
|
|
public void test() throws Throwable {
|
|
Path patchedJavaBase = PATCH_DIR.resolve(JAVA_BASE);
|
|
Path patchedM2 = PATCH_DIR.resolve("m2");
|
|
|
|
Path home = Paths.get(JAVA_HOME);
|
|
runTest(home,
|
|
"--module-path", MODS_DIR.toString(),
|
|
"-m", "m1/p1.Main", "1");
|
|
runTest(home,
|
|
"--patch-module", "java.base=" + patchedJavaBase,
|
|
"--module-path", MODS_DIR.toString(),
|
|
"-m", "m1/p1.Main", "1");
|
|
|
|
runTest(home,
|
|
"--patch-module", "m2=" + patchedM2.toString(),
|
|
"--module-path", MODS_DIR.toString(),
|
|
"-m", "m1/p1.Main", "2");
|
|
}
|
|
|
|
/*
|
|
* Test --patch-module on a custom image
|
|
*/
|
|
@Test
|
|
public void testImage() throws Throwable {
|
|
if (Files.notExists(JMODS))
|
|
return;
|
|
|
|
Path patchedJavaBase = PATCH_DIR.resolve(JAVA_BASE);
|
|
Path patchedM2 = PATCH_DIR.resolve("m2");
|
|
|
|
runTest(IMAGE,
|
|
"-m", "m1/p1.Main", "1");
|
|
runTest(IMAGE,
|
|
"--patch-module", "java.base=" + patchedJavaBase,
|
|
"-m", "m1/p1.Main", "1");
|
|
runTest(IMAGE,
|
|
"--patch-module", "m2=" + patchedM2.toString(),
|
|
"-m", "m1/p1.Main", "2");
|
|
}
|
|
|
|
/*
|
|
* Test a module linked in a system hashed in ModuleHashes attribute
|
|
* cannot be upgraded
|
|
*/
|
|
@Test
|
|
public void upgradeHashedModule() throws Throwable {
|
|
if (Files.notExists(JMODS))
|
|
return;
|
|
|
|
// Fail to upgrade m1.jar with mismatched hash
|
|
runTestWithExitCode(getJava(IMAGE),
|
|
"--upgrade-module-path", NEW_M1_JAR.toString(),
|
|
"-m", "m1/p1.Main");
|
|
|
|
// test when SystemModules fast path is not enabled, i.e. exploded image
|
|
runTestWithExitCode(getJava(IMAGE),
|
|
"--patch-module", "java.base=" + PATCH_DIR.resolve(JAVA_BASE),
|
|
"--upgrade-module-path", NEW_M1_JAR.toString(),
|
|
"-m", "m1/p1.Main");
|
|
}
|
|
|
|
/*
|
|
* Test a module linked in a system hashed in ModuleHashes attribute
|
|
* cannot be upgraded combining with --patch-module and --upgrade-module-path
|
|
*/
|
|
@Test
|
|
public void patchHashedModule() throws Throwable {
|
|
if (Files.notExists(JMODS))
|
|
return;
|
|
|
|
// --patch-module does not disable hash check.
|
|
// Test that a hashed module cannot be upgraded.
|
|
runTestWithExitCode(getJava(IMAGE),
|
|
"--patch-module", "m1=.jar",
|
|
"--upgrade-module-path", NEW_M1_JAR.toString(),
|
|
"-m", "m1/p1.Main");
|
|
|
|
// test when SystemModules fast path is not enabled, i.e. exploded image
|
|
runTestWithExitCode(getJava(IMAGE),
|
|
"--patch-module", "java.base=" + PATCH_DIR.resolve(JAVA_BASE),
|
|
"--patch-module", "m1=.jar",
|
|
"--upgrade-module-path", NEW_M1_JAR.toString(),
|
|
"-m", "m1/p1.Main");
|
|
}
|
|
|
|
private void runTestWithExitCode(String... options) throws Throwable {
|
|
assertTrue(executeCommand(options)
|
|
.outputTo(System.out)
|
|
.errorTo(System.out)
|
|
.shouldContain("differs to expected hash")
|
|
.getExitValue() != 0);
|
|
}
|
|
|
|
private void runTest(Path image, String... opts) throws Throwable {
|
|
String[] options =
|
|
Stream.concat(Stream.of(getJava(image)),
|
|
Stream.of(opts))
|
|
.toArray(String[]::new);
|
|
|
|
ProcessBuilder pb = new ProcessBuilder(options);
|
|
int exitValue = executeCommand(pb)
|
|
.outputTo(System.out)
|
|
.errorTo(System.out)
|
|
.getExitValue();
|
|
|
|
assertTrue(exitValue == 0);
|
|
}
|
|
|
|
static void createJars() throws Throwable {
|
|
FileUtils.deleteFileTreeUnchecked(JARS_DIR);
|
|
|
|
Files.createDirectories(JARS_DIR);
|
|
Path m1 = JARS_DIR.resolve("m1.jar");
|
|
Path m2 = JARS_DIR.resolve("m2.jar");
|
|
|
|
// hash m1 in m2's Hashes attribute
|
|
jar("--create",
|
|
"--file=" + m1.toString(),
|
|
"-C", MODS_DIR.resolve("m1").toString(), ".");
|
|
|
|
jar("--create",
|
|
"--file=" + m2.toString(),
|
|
"--module-path", JARS_DIR.toString(),
|
|
"--hash-modules", "m1",
|
|
"-C", MODS_DIR.resolve("m2").toString(), ".");
|
|
}
|
|
|
|
static void createImage() throws Throwable {
|
|
FileUtils.deleteFileTreeUnchecked(IMAGE);
|
|
|
|
String mpath = JARS_DIR.toString() + File.pathSeparator + JMODS.toString();
|
|
execTool("jlink", "--module-path", mpath,
|
|
"--add-modules", "m1",
|
|
"--output", IMAGE.toString());
|
|
}
|
|
|
|
static void jar(String... args) throws Throwable {
|
|
execTool("jar", args);
|
|
}
|
|
|
|
static void execTool(String tool, String... args) throws Throwable {
|
|
String path = JDKToolFinder.getJDKTool(tool);
|
|
List<String> commands = new ArrayList<>();
|
|
commands.add(path);
|
|
Stream.of(args).forEach(commands::add);
|
|
ProcessBuilder pb = new ProcessBuilder(commands);
|
|
int exitValue = executeCommand(pb)
|
|
.outputTo(System.out)
|
|
.errorTo(System.out)
|
|
.shouldNotContain("no module is recorded in hash")
|
|
.getExitValue();
|
|
|
|
assertTrue(exitValue == 0);
|
|
}
|
|
|
|
static String getJava(Path image) {
|
|
boolean isWindows = System.getProperty("os.name").startsWith("Windows");
|
|
Path java = image.resolve("bin").resolve(isWindows ? "java.exe" : "java");
|
|
if (Files.notExists(java))
|
|
throw new RuntimeException(java + " not found");
|
|
return java.toAbsolutePath().toString();
|
|
}
|
|
}
|