/*
* Copyright (c) 2013, 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.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.Permission;
import java.security.Principal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* This is a test library that makes writing a Java test that spawns multiple
* Java processes easily.
*
* Usage:
*
* Proc.create("Clazz") // The class to launch
* .args("x") // with args
* .env("env", "value") // and an environment variable
* .prop("key","value") // and a system property
* .grant(file) // grant codes in this codebase
* .perm(perm) // with the permission
* .start(); // and start
*
* create/start must be called, args/env/prop/perm can be called zero or
* multiple times between create and start.
*
* The controller can call inheritIO to share its I/O to the process.
* Otherwise, it can send data into a proc's stdin with write/println, and
* read its stdout with readLine. stderr is always redirected to a file
* unless nodump() is called. A protocol is designed to make
* data exchange among the controller and the processes super easy, in which
* useful data are always printed with a special prefix ("PROCISFUN:").
* If the data is binary, make it BASE64.
*
* For example:
*
* - A producer Proc calls Proc.binOut() or Proc.textOut() to send out data.
* This method would prints to the stdout something like
*
* PROCISFUN:[raw text or base64 binary]
*
* - The controller calls producer.readData() to get the content. This method
* ignores all other output and only reads lines starting with "PROCISFUN:".
*
* - The controller does not care if the context is text or base64, it simply
* feeds the data to a consumer Proc by calling consumer.println(data).
* This will be printed into System.in of the consumer process.
*
* - The consumer Proc calls Proc.binIn() or Proc.textIn() to read the data.
* The first method de-base64 the input and return a byte[] block.
*
* Please note only plain ASCII is supported in raw text at the moment.
*
* As the Proc objects are hidden so deeply, two static methods, d(String) and
* d(Throwable) are provided to output info into stderr, where they will
* normally be appended messages to a debug file (unless nodump() is called).
* Developers can view the messages in real time by calling
*
* {@code tail -f stderr.<debug>}
*
* TODO:
*
* . launch java tools, say, keytool
* . launch another version of java
* . start in another directory
* . start and finish using one method
*
* This is not a test, but is the core of
* JDK-8009977: A test library to launch multiple Java processes
*/
public class Proc {
private Process p;
private BufferedReader br; // the stdout of a process
private String launcher; // Optional: the java program
private List<String> args = new ArrayList<>();
private Map<String,String> env = new HashMap<>();
private Map<String,String> prop = new HashMap();
private boolean inheritIO = false;
private boolean noDump = false;
private List<String> cp; // user-provided classpath
private String clazz; // Class to launch
private String debug; // debug flag, controller will show data
// transfer between procs. If debug is set,
// it MUST be different between Procs.
final private static String PREFIX = "PROCISFUN:";
// policy file
final private StringBuilder perms = new StringBuilder();
// temporary saving the grant line in a policy file
final private StringBuilder grant = new StringBuilder();
// The following methods are called by controllers
// Creates a Proc by the Java class name, launcher is an optional
// argument to specify the java program
public static Proc create(String clazz, String... launcher) {
Proc pc = new Proc();
pc.clazz = clazz;
if (launcher.length > 0) {
pc.launcher = launcher[0];
}
return pc;
}
// Sets inheritIO flag to proc. If set, proc will same I/O channels as
// teh controller. Otherwise, its stdin/stdout is untouched, and its
// stderr is redirected to DFILE.
public Proc inheritIO() {
inheritIO = true;
return this;
}
// When called, stderr inherits parent stderr, otherwise, append to a file
public Proc nodump() {
noDump = true;
return this;
}
// Specifies some args. Can be called multiple times.
public Proc args(String... args) {
for (String c: args) {
this.args.add(c);
}
return this;
}
// Returns debug prefix
public String debug() {
return debug;
}
// Enables debug with prefix
public Proc debug(String title) {
debug = title;
return this;
}
// Specifies an env var. Can be called multiple times.
public Proc env(String a, String b) {
env.put(a, b);
return this;
}
// Specifies a Java system property. Can be called multiple times.
public Proc prop(String a, String b) {
prop.put(a, b);
return this;
}
// Sets classpath. If not called, Proc will choose a classpath. If called
// with no arg, no classpath will be used. Can be called multiple times.
public Proc cp(String... s) {
if (cp == null) {
cp = new ArrayList<>();
}
cp.addAll(Arrays.asList(s));
return this;
}
// Adds a permission to policy. Can be called multiple times.
// All perm() calls after a series of grant() calls are grouped into
// a single grant block. perm() calls before any grant() call are grouped
// into a grant block with no restriction.
// Please note that in order to make permissions effective, also call
// prop("java.security.manager", "").
public Proc perm(Permission p) {
if (grant.length() != 0) { // Right after grant(s)
if (perms.length() != 0) { // Not first block
perms.append("};\n");
}
perms.append("grant ").append(grant).append(" {\n");
grant.setLength(0);
} else {
if (perms.length() == 0) { // First block w/o restriction
perms.append("grant {\n");
}
}
if (p.getActions().isEmpty()) {
String s = String.format("%s \"%s\"",
p.getClass().getCanonicalName(),
p.getName()
.replace("\\", "\\\\").replace("\"", "\\\""));
perms.append(" permission ").append(s).append(";\n");
} else {
String s = String.format("%s \"%s\", \"%s\"",
p.getClass().getCanonicalName(),
p.getName()
.replace("\\", "\\\\").replace("\"", "\\\""),
p.getActions());
perms.append(" permission ").append(s).append(";\n");
}
return this;
}
// Adds a grant option to policy. If called in a row, a single grant block
// with all options will be created. If there are perm() call(s) between
// grant() calls, they belong to different grant blocks
// grant on a principal
public Proc grant(Principal p) {
grant.append("principal ").append(p.getClass().getName())
.append(" \"").append(p.getName()).append("\", ");
return this;
}
// grant on a codebase
public Proc grant(File f) {
grant.append("codebase \"").append(f.toURI()).append("\", ");
return this;
}
// arbitrary grant
public Proc grant(String v) {
grant.append(v).append(", ");
return this;
}
// Starts the proc
public Proc start() throws IOException {
List<String> cmd = new ArrayList<>();
boolean hasModules;
if (launcher != null) {
cmd.add(launcher);
File base = new File(launcher).getParentFile().getParentFile();
hasModules = new File(base, "modules").exists() ||
new File(base, "jmods").exists();
} else {
cmd.add(new File(new File(System.getProperty("java.home"), "bin"),
"java").getPath());
hasModules = true;
}
if (hasModules) {
Stream.of(jdk.internal.misc.VM.getRuntimeArguments())
.filter(arg -> arg.startsWith("--add-exports="))
.forEach(cmd::add);
}
Collections.addAll(cmd, splitProperty("test.vm.opts"));
Collections.addAll(cmd, splitProperty("test.java.opts"));
if (cp == null) {
cmd.add("-cp");
cmd.add(System.getProperty("test.class.path") + File.pathSeparator +
System.getProperty("test.src.path"));
} else if (!cp.isEmpty()) {
cmd.add("-cp");
cmd.add(cp.stream().collect(Collectors.joining(File.pathSeparator)));
}
for (Entry<String,String> e: prop.entrySet()) {
cmd.add("-D" + e.getKey() + "=" + e.getValue());
}
if (perms.length() > 0) {
Path p = Paths.get(getId("policy")).toAbsolutePath();
perms.append("};\n");
Files.write(p, perms.toString().getBytes());
cmd.add("-Djava.security.policy=" + p.toString());
}
cmd.add(clazz);
for (String s: args) {
cmd.add(s);
}
if (debug != null) {
System.out.println("PROC: " + debug + " cmdline: " + cmd);
for (String c : cmd) {
if (c.indexOf('\\') >= 0 || c.indexOf(' ') > 0) {
System.out.print('\'' + c + '\'');
} else {
System.out.print(c);
}
System.out.print(' ');
}
System.out.println();
}
ProcessBuilder pb = new ProcessBuilder(cmd);
for (Entry<String,String> e: env.entrySet()) {
pb.environment().put(e.getKey(), e.getValue());
}
if (inheritIO) {
pb.inheritIO();
} else if (noDump) {
pb.redirectError(ProcessBuilder.Redirect.INHERIT);
} else {
pb.redirectError(ProcessBuilder.Redirect
.appendTo(new File(getId("stderr"))));
}
p = pb.start();
br = new BufferedReader(new InputStreamReader(p.getInputStream()));
return this;
}
String getId(String prefix) {
if (debug != null) return prefix + "." + debug;
else return prefix + "." + System.identityHashCode(this);
}
// Reads a line from stdout of proc
public String readLine() throws IOException {
String s = br.readLine();
if (debug != null) {
System.out.println("PROC: " + debug + " readline: " +
(s == null ? "<EOF>" : s));
}
return s;
}
// Reads a special line from stdout of proc
public String readData() throws Exception {
while (true) {
String s = readLine();
if (s == null) {
if (p.waitFor() != 0) {
throw new Exception("Proc abnormal end");
} else {
return s;
}
}
if (s.startsWith(PREFIX)) {
return s.substring(PREFIX.length());
}
}
}
// Writes text into stdin of proc
public void println(String s) throws IOException {
if (debug != null) {
System.out.println("PROC: " + debug + " println: " + s);
}
write((s + "\n").getBytes());
}
// Writes data into stdin of proc
public void write(byte[] b) throws IOException {
p.getOutputStream().write(b);
p.getOutputStream().flush();
}
// Reads all output and wait for process end
public int waitFor() throws Exception {
while (true) {
String s = readLine();
if (s == null) {
break;
}
}
return p.waitFor();
}
// The following methods are used inside a proc
// Writes out a BASE64 binary with a prefix
public static void binOut(byte[] data) {
System.out.println(PREFIX + Base64.getEncoder().encodeToString(data));
}
// Reads in a line of BASE64 binary
public static byte[] binIn() throws Exception {
return Base64.getDecoder().decode(textIn());
}
// Writes out a text with a prefix
public static void textOut(String data) {
System.out.println(PREFIX + data);
}
// Reads in a line of text
public static String textIn() throws Exception {
StringBuilder sb = new StringBuilder();
boolean isEmpty = true;
while (true) {
int i = System.in.read();
if (i == -1) break;
isEmpty = false;
if (i == '\n') break;
if (i != 13) {
// Force it to a char, so only simple ASCII works.
sb.append((char)i);
}
}
return isEmpty ? null : sb.toString();
}
// Sends string to stderr. If inheritIO is not called, they will
// be collected into DFILE
public static void d(String s) throws IOException {
System.err.println(s);
}
// Sends an exception to stderr
public static void d(Throwable e) throws IOException {
e.printStackTrace();
}
private static String[] splitProperty(String prop) {
String s = System.getProperty(prop);
if (s == null || s.trim().isEmpty()) {
return new String[] {};
}
return s.trim().split("\\s+");
}
}