272 lines
9.1 KiB
Java
272 lines
9.1 KiB
Java
/*
|
|
* Copyright (c) 2013, 2015, 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.
|
|
*/
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.nio.file.FileSystem;
|
|
import java.nio.file.FileSystems;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.LinkOption;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.StandardCopyOption;
|
|
import java.nio.file.attribute.PosixFilePermission;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
|
|
import jdk.testlibrary.ProcessTools;
|
|
|
|
/**
|
|
* @test
|
|
* @bug 6434402 8004926
|
|
* @library /lib/testlibrary
|
|
* @modules java.management/sun.management
|
|
* java.management
|
|
* @build jdk.testlibrary.*
|
|
* @build TestManager TestApplication CustomLauncherTest
|
|
* @run main/othervm CustomLauncherTest
|
|
* @author Jaroslav Bachorik
|
|
*/
|
|
public class CustomLauncherTest {
|
|
private static final String TEST_CLASSPATH = System.getProperty("test.class.path");
|
|
private static final String TEST_JDK = System.getProperty("test.jdk");
|
|
private static final String WORK_DIR = System.getProperty("user.dir");
|
|
|
|
private static final String TEST_SRC = System.getProperty("test.src");
|
|
private static final String OSNAME = System.getProperty("os.name");
|
|
private static final String ARCH;
|
|
private static final String LIBARCH;
|
|
|
|
static {
|
|
// magic with os.arch
|
|
String osarch = System.getProperty("os.arch");
|
|
switch (osarch) {
|
|
case "i386":
|
|
case "i486":
|
|
case "i586":
|
|
case "i686":
|
|
case "i786":
|
|
case "i886":
|
|
case "i986": {
|
|
ARCH = "i586";
|
|
break;
|
|
}
|
|
case "x86_64":
|
|
case "amd64": {
|
|
ARCH = "amd64";
|
|
break;
|
|
}
|
|
case "sparc":
|
|
ARCH = "sparcv9";
|
|
break;
|
|
default: {
|
|
ARCH = osarch;
|
|
}
|
|
}
|
|
LIBARCH = ARCH.equals("i586") ? "i386" : ARCH;
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
if (TEST_CLASSPATH == null || TEST_CLASSPATH.isEmpty()) {
|
|
System.out.println("Test is designed to be run from jtreg only");
|
|
return;
|
|
}
|
|
|
|
if (getPlatform() == null) {
|
|
System.out.println("Test not designed to run on this operating " +
|
|
"system (" + OSNAME + "), skipping...");
|
|
return;
|
|
}
|
|
|
|
final FileSystem FS = FileSystems.getDefault();
|
|
|
|
Path libjvmPath = findLibjvm(FS);
|
|
if (libjvmPath == null) {
|
|
throw new Error("Unable to locate 'libjvm.so' in " + TEST_JDK);
|
|
}
|
|
|
|
Process serverPrc = null, clientPrc = null;
|
|
|
|
try {
|
|
String[] launcher = getLauncher();
|
|
|
|
if (launcher == null) return; // launcher not available for the tested platform; skip
|
|
|
|
System.out.println("Starting custom launcher:");
|
|
System.out.println("=========================");
|
|
System.out.println(" launcher : " + launcher[0]);
|
|
System.out.println(" libjvm : " + libjvmPath.toString());
|
|
System.out.println(" classpath : " + TEST_CLASSPATH);
|
|
ProcessBuilder server = new ProcessBuilder(
|
|
launcher[1],
|
|
libjvmPath.toString(),
|
|
TEST_CLASSPATH,
|
|
"TestApplication"
|
|
);
|
|
|
|
final AtomicReference<String> port = new AtomicReference<>();
|
|
|
|
serverPrc = ProcessTools.startProcess(
|
|
"Launcher",
|
|
server,
|
|
(String line) -> {
|
|
if (line.startsWith("port:")) {
|
|
port.set(line.split("\\:")[1]);
|
|
} else if (line.startsWith("waiting")) {
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
5,
|
|
TimeUnit.SECONDS
|
|
);
|
|
|
|
System.out.println("Attaching test manager:");
|
|
System.out.println("=========================");
|
|
System.out.println(" PID : " + serverPrc.getPid());
|
|
System.out.println(" shutdown port : " + port.get());
|
|
|
|
ProcessBuilder client = ProcessTools.createJavaProcessBuilder(
|
|
"-cp",
|
|
TEST_CLASSPATH,
|
|
"TestManager",
|
|
String.valueOf(serverPrc.getPid()),
|
|
port.get(),
|
|
"true"
|
|
);
|
|
|
|
clientPrc = ProcessTools.startProcess(
|
|
"TestManager",
|
|
client,
|
|
(String line) -> line.startsWith("Starting TestManager for PID"),
|
|
10,
|
|
TimeUnit.SECONDS
|
|
);
|
|
|
|
int clientExitCode = clientPrc.waitFor();
|
|
int serverExitCode = serverPrc.waitFor();
|
|
|
|
if (clientExitCode != 0 || serverExitCode != 0) {
|
|
throw new Error("Test failed");
|
|
}
|
|
} finally {
|
|
if (clientPrc != null) {
|
|
clientPrc.destroy();
|
|
clientPrc.waitFor();
|
|
}
|
|
if (serverPrc != null) {
|
|
serverPrc.destroy();
|
|
serverPrc.waitFor();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Path findLibjvm(FileSystem FS) {
|
|
Path libjvmPath = findLibjvm(FS.getPath(TEST_JDK, "jre", "lib", LIBARCH));
|
|
if (libjvmPath == null) {
|
|
libjvmPath = findLibjvm(FS.getPath(TEST_JDK, "lib", LIBARCH));
|
|
}
|
|
return libjvmPath;
|
|
}
|
|
|
|
private static Path findLibjvm(Path libPath) {
|
|
// ARCH/libjvm.so -> ARCH/server/libjvm.so -> ARCH/client/libjvm.so
|
|
Path libjvmPath = libPath.resolve("libjvm.so");
|
|
if (isFileOk(libjvmPath)) {
|
|
return libjvmPath;
|
|
}
|
|
libjvmPath = libPath.resolve("server/libjvm.so");
|
|
if (isFileOk(libjvmPath)) {
|
|
return libjvmPath;
|
|
}
|
|
libjvmPath = libPath.resolve("client/libjvm.so");
|
|
if (isFileOk(libPath)) {
|
|
return libjvmPath;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static boolean isFileOk(Path path) {
|
|
return Files.isRegularFile(path) && Files.isReadable(path);
|
|
}
|
|
|
|
private static String getPlatform() {
|
|
String platform = null;
|
|
switch (OSNAME.toLowerCase()) {
|
|
case "linux": {
|
|
platform = "linux";
|
|
break;
|
|
}
|
|
case "sunos": {
|
|
platform = "solaris";
|
|
break;
|
|
}
|
|
default: {
|
|
platform = null;
|
|
}
|
|
}
|
|
|
|
return platform;
|
|
}
|
|
|
|
private static String[] getLauncher() throws IOException {
|
|
String platform = getPlatform();
|
|
if (platform == null) {
|
|
return null;
|
|
}
|
|
|
|
String launcher = TEST_SRC + File.separator + platform + "-" + ARCH +
|
|
File.separator + "launcher";
|
|
|
|
final FileSystem FS = FileSystems.getDefault();
|
|
Path launcherPath = FS.getPath(launcher);
|
|
|
|
final boolean hasLauncher = Files.isRegularFile(launcherPath, LinkOption.NOFOLLOW_LINKS)&&
|
|
Files.isReadable(launcherPath);
|
|
if (!hasLauncher) {
|
|
System.out.println("Launcher [" + launcher + "] does not exist. Skipping the test.");
|
|
return null;
|
|
}
|
|
|
|
// It is impossible to store an executable file in the source control
|
|
// We need to copy the launcher to the working directory
|
|
// and set the executable flag
|
|
Path localLauncherPath = FS.getPath(WORK_DIR, "launcher");
|
|
Files.copy(launcherPath, localLauncherPath,
|
|
StandardCopyOption.REPLACE_EXISTING);
|
|
if (!Files.isExecutable(localLauncherPath)) {
|
|
Set<PosixFilePermission> perms = new HashSet<>(
|
|
Files.getPosixFilePermissions(
|
|
localLauncherPath,
|
|
LinkOption.NOFOLLOW_LINKS
|
|
)
|
|
);
|
|
perms.add(PosixFilePermission.OWNER_EXECUTE);
|
|
Files.setPosixFilePermissions(localLauncherPath, perms);
|
|
}
|
|
return new String[] {launcher, localLauncherPath.toAbsolutePath().toString()};
|
|
}
|
|
}
|