| /* |
| * 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.net.URL; |
| import java.net.URLClassLoader; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.security.Permission; |
| import java.util.ArrayList; |
| import java.util.Base64; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| /** |
| * 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 |
| * .perm(perm) // with granted permissions |
| * .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 DFILE |
| * 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 DFILE (unless nodump() is called). |
| * Developers can view the messages in real time by calling |
| * |
| * tail -f proc.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<Permission> perms = new ArrayList<>(); |
| 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 String clazz; // Class to launch |
| private String debug; // debug flag, controller will show data |
| // transfer between procs |
| |
| final private static String PREFIX = "PROCISFUN:"; |
| final private static String DFILE = "proc.debug"; |
| |
| // 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; |
| } |
| // Adds a perm to policy. Can be called multiple times. In order to make it |
| // effective, please also call prop("java.security.manager", ""). |
| public Proc perm(Permission p) { |
| perms.add(p); |
| return this; |
| } |
| // Starts the proc |
| public Proc start() throws IOException { |
| List<String> cmd = new ArrayList<>(); |
| if (launcher != null) { |
| cmd.add(launcher); |
| } else { |
| cmd.add(new File(new File(System.getProperty("java.home"), "bin"), |
| "java").getPath()); |
| } |
| cmd.add("-cp"); |
| StringBuilder cp = new StringBuilder(); |
| for (URL url: ((URLClassLoader)Proc.class.getClassLoader()).getURLs()) { |
| if (cp.length() != 0) { |
| cp.append(File.pathSeparatorChar); |
| } |
| cp.append(url.getFile()); |
| } |
| cmd.add(cp.toString()); |
| for (Entry<String,String> e: prop.entrySet()) { |
| cmd.add("-D" + e.getKey() + "=" + e.getValue()); |
| } |
| if (!perms.isEmpty()) { |
| Path p = Files.createTempFile( |
| Paths.get(".").toAbsolutePath(), "policy", null); |
| StringBuilder sb = new StringBuilder(); |
| sb.append("grant {\n"); |
| for (Permission perm: perms) { |
| // Sometimes a permission has no name or actions. |
| // but it's safe to use an empty string. |
| String s = String.format("%s \"%s\", \"%s\"", |
| perm.getClass().getCanonicalName(), |
| perm.getName() |
| .replace("\\", "\\\\").replace("\"", "\\\""), |
| perm.getActions()); |
| sb.append(" permission ").append(s).append(";\n"); |
| } |
| sb.append("};\n"); |
| Files.write(p, sb.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); |
| } |
| 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(DFILE))); |
| } |
| p = pb.start(); |
| br = new BufferedReader(new InputStreamReader(p.getInputStream())); |
| return 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(); |
| } |
| } |