langtools/src/jdk.jshell/share/classes/jdk/jshell/execution/JdiDefaultExecutionControl.java - platform/libcore - Git at Google

 /*
  * 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.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * 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.
  */
 package jdk.jshell.execution;

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.ObjectInput;
 import java.io.ObjectOutput;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.security.SecureRandom;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;

 import com.sun.jdi.BooleanValue;
 import com.sun.jdi.ClassNotLoadedException;
 import com.sun.jdi.Field;
 import com.sun.jdi.IncompatibleThreadStateException;
 import com.sun.jdi.InvalidTypeException;
 import com.sun.jdi.ObjectReference;
 import com.sun.jdi.StackFrame;
 import com.sun.jdi.ThreadReference;
 import com.sun.jdi.VMDisconnectedException;
 import com.sun.jdi.VirtualMachine;
 import jdk.jshell.spi.ExecutionControl;
 import jdk.jshell.spi.ExecutionEnv;
 import static jdk.jshell.execution.Util.remoteInputOutput;

 /**
  * The implementation of {@link jdk.jshell.spi.ExecutionControl} that the
  * JShell-core uses by default.
  * Launches a remote process -- the "remote agent".
  * Interfaces to the remote agent over a socket and via JDI.
  * Designed to work with {@link RemoteExecutionControl}.
  *
  * @author Robert Field
  * @author Jan Lahoda
  */
 public class JdiDefaultExecutionControl extends JdiExecutionControl {

     private static final String REMOTE_AGENT = RemoteExecutionControl.class.getName();

     private VirtualMachine vm;
     private Process process;

     private final Object STOP_LOCK = new Object();
     private boolean userCodeRunning = false;

     /**
      * Creates an ExecutionControl instance based on a JDI
      * {@code LaunchingConnector}.
      *
      * @return the generator
      */
     public static ExecutionControl.Generator launch() {
         return env -> create(env, true, null);
     }

     /**
      * Creates an ExecutionControl instance based on a JDI
      * {@code ListeningConnector}.
      *
      * @param host explicit hostname to use, if null use discovered
      * hostname, applies to listening only (!isLaunch)
      * @return the generator
      */
     public static ExecutionControl.Generator listen(String host) {
         return env -> create(env, false, host);
     }

     /**
      * Creates an ExecutionControl instance based on a JDI
      * {@code ListeningConnector} or {@code LaunchingConnector}.
      *
      * Initialize JDI and use it to launch the remote JVM. Set-up a socket for
      * commands and results. This socket also transports the user
      * input/output/error.
      *
      * @param env the context passed by
      * {@link jdk.jshell.spi.ExecutionControl#start(jdk.jshell.spi.ExecutionEnv) }
      * @param isLaunch does JDI do the launch? That is, LaunchingConnector,
      * otherwise we start explicitly and use ListeningConnector
      * @param host explicit hostname to use, if null use discovered
      * hostname, applies to listening only (!isLaunch)
      * @return the channel
      * @throws IOException if there are errors in set-up
      */
     private static ExecutionControl create(ExecutionEnv env,
             boolean isLaunch, String host) throws IOException {
         try (final ServerSocket listener = new ServerSocket(0, 1, InetAddress.getLoopbackAddress())) {
             // timeout after 60 seconds
             listener.setSoTimeout(60000);
             int port = listener.getLocalPort();

             // Set-up the JDI connection
             JdiInitiator jdii = new JdiInitiator(port,
                     env.extraRemoteVMOptions(), REMOTE_AGENT, isLaunch, host);
             VirtualMachine vm = jdii.vm();
             Process process = jdii.process();

             OutputStream processOut = process.getOutputStream();
             SecureRandom rng = new SecureRandom();
             byte[] randomBytes = new byte[VERIFY_HASH_LEN];

             rng.nextBytes(randomBytes);
             processOut.write(randomBytes);
             processOut.flush();

             List<Consumer<String>> deathListeners = new ArrayList<>();
             deathListeners.add(s -> env.closeDown());
             Util.detectJdiExitEvent(vm, s -> {
                 for (Consumer<String> h : deathListeners) {
                     h.accept(s);
                 }
             });

             ByteArrayOutputStream receivedRandomBytes = new ByteArrayOutputStream();

             // Set-up the commands/reslts on the socket.  Piggy-back snippet
             // output.
             Socket socket = listener.accept();
             // out before in -- match remote creation so we don't hang
             OutputStream out = socket.getOutputStream();
             Map<String, OutputStream> outputs = new HashMap<>();
             outputs.put("out", env.userOut());
             outputs.put("err", env.userErr());
             outputs.put("echo", new OutputStream() {
                 @Override public void write(int b) throws IOException {
                     synchronized (receivedRandomBytes) {
                         receivedRandomBytes.write(b);
                         receivedRandomBytes.notify();
                     }
                 }
             });
             Map<String, InputStream> input = new HashMap<>();
             input.put("in", env.userIn());
             return remoteInputOutput(socket.getInputStream(), out, outputs, input, (objIn, objOut) -> {
                 synchronized (receivedRandomBytes) {
                     while (receivedRandomBytes.size() < randomBytes.length) {
                         try {
                             receivedRandomBytes.wait();
                         } catch (InterruptedException ex) {
                             //ignore
                         }
                     }
                     if (!Arrays.equals(receivedRandomBytes.toByteArray(), randomBytes)) {
                         throw new IllegalStateException("Invalid connection!");
                     }
                 }
                 return new JdiDefaultExecutionControl(objOut, objIn, vm, process, deathListeners);
             });
         }
     }
     //where:
         private static final int VERIFY_HASH_LEN = 20;

     /**
      * Create an instance.
      *
      * @param cmdout the output for commands
      * @param cmdin the input for responses
      */
     private JdiDefaultExecutionControl(ObjectOutput cmdout, ObjectInput cmdin,
             VirtualMachine vm, Process process, List<Consumer<String>> deathListeners) {
         super(cmdout, cmdin);
         this.vm = vm;
         this.process = process;
         deathListeners.add(s -> disposeVM());
     }

     @Override
     public String invoke(String classname, String methodname)
             throws RunException,
             EngineTerminationException, InternalException {
         String res;
         synchronized (STOP_LOCK) {
             userCodeRunning = true;
         }
         try {
             res = super.invoke(classname, methodname);
         } finally {
             synchronized (STOP_LOCK) {
                 userCodeRunning = false;
             }
         }
         return res;
     }

     /**
      * Interrupts a running remote invoke by manipulating remote variables
      * and sending a stop via JDI.
      *
      * @throws EngineTerminationException the execution engine has terminated
      * @throws InternalException an internal problem occurred
      */
     @Override
     public void stop() throws EngineTerminationException, InternalException {
         synchronized (STOP_LOCK) {
             if (!userCodeRunning) {
                 return;
             }

             vm().suspend();
             try {
                 OUTER:
                 for (ThreadReference thread : vm().allThreads()) {
                     // could also tag the thread (e.g. using name), to find it easier
                     for (StackFrame frame : thread.frames()) {
                         if (REMOTE_AGENT.equals(frame.location().declaringType().name()) &&
                                 (    "invoke".equals(frame.location().method().name())
                                 || "varValue".equals(frame.location().method().name()))) {
                             ObjectReference thiz = frame.thisObject();
                             Field inClientCode = thiz.referenceType().fieldByName("inClientCode");
                             Field expectingStop = thiz.referenceType().fieldByName("expectingStop");
                             Field stopException = thiz.referenceType().fieldByName("stopException");
                             if (((BooleanValue) thiz.getValue(inClientCode)).value()) {
                                 thiz.setValue(expectingStop, vm().mirrorOf(true));
                                 ObjectReference stopInstance = (ObjectReference) thiz.getValue(stopException);

                                 vm().resume();
                                 debug("Attempting to stop the client code...\n");
                                 thread.stop(stopInstance);
                                 thiz.setValue(expectingStop, vm().mirrorOf(false));
                             }

                             break OUTER;
                         }
                     }
                 }
             } catch (ClassNotLoadedException | IncompatibleThreadStateException | InvalidTypeException ex) {
                 throw new InternalException("Exception on remote stop: " + ex);
             } finally {
                 vm().resume();
             }
         }
     }

     @Override
     public void close() {
         super.close();
         disposeVM();
     }

     private synchronized void disposeVM() {
         try {
             if (vm != null) {
                 vm.dispose(); // This could NPE, so it is caught below
                 vm = null;
             }
         } catch (VMDisconnectedException ex) {
             // Ignore if already closed
         } catch (Throwable ex) {
             debug(ex, "disposeVM");
         } finally {
             if (process != null) {
                 process.destroy();
                 process = null;
             }
         }
     }

     @Override
     protected synchronized VirtualMachine vm() throws EngineTerminationException {
         if (vm == null) {
             throw new EngineTerminationException("VM closed");
         } else {
             return vm;
         }
     }

     /**
      * Log debugging information. Arguments as for {@code printf}.
      *
      * @param format a format string as described in Format string syntax
      * @param args arguments referenced by the format specifiers in the format
      * string.
      */
     private static void debug(String format, Object... args) {
         // Reserved for future logging
     }

     /**
      * Log a serious unexpected internal exception.
      *
      * @param ex the exception
      * @param where a description of the context of the exception
      */
     private static void debug(Throwable ex, String where) {
         // Reserved for future logging
     }

 }
	/*
	* 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/
	package jdk.jshell.execution;

	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.ObjectInput;
	import java.io.ObjectOutput;
	import java.io.OutputStream;
	import java.net.InetAddress;
	import java.net.ServerSocket;
	import java.net.Socket;
	import java.security.SecureRandom;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.function.Consumer;

	import com.sun.jdi.BooleanValue;
	import com.sun.jdi.ClassNotLoadedException;
	import com.sun.jdi.Field;
	import com.sun.jdi.IncompatibleThreadStateException;
	import com.sun.jdi.InvalidTypeException;
	import com.sun.jdi.ObjectReference;
	import com.sun.jdi.StackFrame;
	import com.sun.jdi.ThreadReference;
	import com.sun.jdi.VMDisconnectedException;
	import com.sun.jdi.VirtualMachine;
	import jdk.jshell.spi.ExecutionControl;
	import jdk.jshell.spi.ExecutionEnv;
	import static jdk.jshell.execution.Util.remoteInputOutput;

	/**
	* The implementation of {@link jdk.jshell.spi.ExecutionControl} that the
	* JShell-core uses by default.
	* Launches a remote process -- the "remote agent".
	* Interfaces to the remote agent over a socket and via JDI.
	* Designed to work with {@link RemoteExecutionControl}.
	*
	* @author Robert Field
	* @author Jan Lahoda
	*/
	public class JdiDefaultExecutionControl extends JdiExecutionControl {

	private static final String REMOTE_AGENT = RemoteExecutionControl.class.getName();

	private VirtualMachine vm;
	private Process process;

	private final Object STOP_LOCK = new Object();
	private boolean userCodeRunning = false;

	/**
	* Creates an ExecutionControl instance based on a JDI
	* {@code LaunchingConnector}.
	*
	* @return the generator
	*/
	public static ExecutionControl.Generator launch() {
	return env -> create(env, true, null);
	}

	/**
	* Creates an ExecutionControl instance based on a JDI
	* {@code ListeningConnector}.
	*
	* @param host explicit hostname to use, if null use discovered
	* hostname, applies to listening only (!isLaunch)
	* @return the generator
	*/
	public static ExecutionControl.Generator listen(String host) {
	return env -> create(env, false, host);
	}

	/**
	* Creates an ExecutionControl instance based on a JDI
	* {@code ListeningConnector} or {@code LaunchingConnector}.
	*
	* Initialize JDI and use it to launch the remote JVM. Set-up a socket for
	* commands and results. This socket also transports the user
	* input/output/error.
	*
	* @param env the context passed by
	* {@link jdk.jshell.spi.ExecutionControl#start(jdk.jshell.spi.ExecutionEnv) }
	* @param isLaunch does JDI do the launch? That is, LaunchingConnector,
	* otherwise we start explicitly and use ListeningConnector
	* @param host explicit hostname to use, if null use discovered
	* hostname, applies to listening only (!isLaunch)
	* @return the channel
	* @throws IOException if there are errors in set-up
	*/
	private static ExecutionControl create(ExecutionEnv env,
	boolean isLaunch, String host) throws IOException {
	try (final ServerSocket listener = new ServerSocket(0, 1, InetAddress.getLoopbackAddress())) {
	// timeout after 60 seconds
	listener.setSoTimeout(60000);
	int port = listener.getLocalPort();

	// Set-up the JDI connection
	JdiInitiator jdii = new JdiInitiator(port,
	env.extraRemoteVMOptions(), REMOTE_AGENT, isLaunch, host);
	VirtualMachine vm = jdii.vm();
	Process process = jdii.process();

	OutputStream processOut = process.getOutputStream();
	SecureRandom rng = new SecureRandom();
	byte[] randomBytes = new byte[VERIFY_HASH_LEN];

	rng.nextBytes(randomBytes);
	processOut.write(randomBytes);
	processOut.flush();

	List<Consumer<String>> deathListeners = new ArrayList<>();
	deathListeners.add(s -> env.closeDown());
	Util.detectJdiExitEvent(vm, s -> {
	for (Consumer<String> h : deathListeners) {
	h.accept(s);
	}
	});

	ByteArrayOutputStream receivedRandomBytes = new ByteArrayOutputStream();

	// Set-up the commands/reslts on the socket. Piggy-back snippet
	// output.
	Socket socket = listener.accept();
	// out before in -- match remote creation so we don't hang
	OutputStream out = socket.getOutputStream();
	Map<String, OutputStream> outputs = new HashMap<>();
	outputs.put("out", env.userOut());
	outputs.put("err", env.userErr());
	outputs.put("echo", new OutputStream() {
	@Override public void write(int b) throws IOException {
	synchronized (receivedRandomBytes) {
	receivedRandomBytes.write(b);
	receivedRandomBytes.notify();
	}
	}
	});
	Map<String, InputStream> input = new HashMap<>();
	input.put("in", env.userIn());
	return remoteInputOutput(socket.getInputStream(), out, outputs, input, (objIn, objOut) -> {
	synchronized (receivedRandomBytes) {
	while (receivedRandomBytes.size() < randomBytes.length) {
	try {
	receivedRandomBytes.wait();
	} catch (InterruptedException ex) {
	//ignore
	}
	}
	if (!Arrays.equals(receivedRandomBytes.toByteArray(), randomBytes)) {
	throw new IllegalStateException("Invalid connection!");
	}
	}
	return new JdiDefaultExecutionControl(objOut, objIn, vm, process, deathListeners);
	});
	}
	}
	//where:
	private static final int VERIFY_HASH_LEN = 20;

	/**
	* Create an instance.
	*
	* @param cmdout the output for commands
	* @param cmdin the input for responses
	*/
	private JdiDefaultExecutionControl(ObjectOutput cmdout, ObjectInput cmdin,
	VirtualMachine vm, Process process, List<Consumer<String>> deathListeners) {
	super(cmdout, cmdin);
	this.vm = vm;
	this.process = process;
	deathListeners.add(s -> disposeVM());
	}

	@Override
	public String invoke(String classname, String methodname)
	throws RunException,
	EngineTerminationException, InternalException {
	String res;
	synchronized (STOP_LOCK) {
	userCodeRunning = true;
	}
	try {
	res = super.invoke(classname, methodname);
	} finally {
	synchronized (STOP_LOCK) {
	userCodeRunning = false;
	}
	}
	return res;
	}

	/**
	* Interrupts a running remote invoke by manipulating remote variables
	* and sending a stop via JDI.
	*
	* @throws EngineTerminationException the execution engine has terminated
	* @throws InternalException an internal problem occurred
	*/
	@Override
	public void stop() throws EngineTerminationException, InternalException {
	synchronized (STOP_LOCK) {
	if (!userCodeRunning) {
	return;
	}

	vm().suspend();
	try {
	OUTER:
	for (ThreadReference thread : vm().allThreads()) {
	// could also tag the thread (e.g. using name), to find it easier
	for (StackFrame frame : thread.frames()) {
	if (REMOTE_AGENT.equals(frame.location().declaringType().name()) &&
	( "invoke".equals(frame.location().method().name())
	\|\| "varValue".equals(frame.location().method().name()))) {
	ObjectReference thiz = frame.thisObject();
	Field inClientCode = thiz.referenceType().fieldByName("inClientCode");
	Field expectingStop = thiz.referenceType().fieldByName("expectingStop");
	Field stopException = thiz.referenceType().fieldByName("stopException");
	if (((BooleanValue) thiz.getValue(inClientCode)).value()) {
	thiz.setValue(expectingStop, vm().mirrorOf(true));
	ObjectReference stopInstance = (ObjectReference) thiz.getValue(stopException);

	vm().resume();
	debug("Attempting to stop the client code...\n");
	thread.stop(stopInstance);
	thiz.setValue(expectingStop, vm().mirrorOf(false));
	}

	break OUTER;
	}
	}
	}
	} catch (ClassNotLoadedException \| IncompatibleThreadStateException \| InvalidTypeException ex) {
	throw new InternalException("Exception on remote stop: " + ex);
	} finally {
	vm().resume();
	}
	}
	}

	@Override
	public void close() {
	super.close();
	disposeVM();
	}

	private synchronized void disposeVM() {
	try {
	if (vm != null) {
	vm.dispose(); // This could NPE, so it is caught below
	vm = null;
	}
	} catch (VMDisconnectedException ex) {
	// Ignore if already closed
	} catch (Throwable ex) {
	debug(ex, "disposeVM");
	} finally {
	if (process != null) {
	process.destroy();
	process = null;
	}
	}
	}

	@Override
	protected synchronized VirtualMachine vm() throws EngineTerminationException {
	if (vm == null) {
	throw new EngineTerminationException("VM closed");
	} else {
	return vm;
	}
	}

	/**
	* Log debugging information. Arguments as for {@code printf}.
	*
	* @param format a format string as described in Format string syntax
	* @param args arguments referenced by the format specifiers in the format
	* string.
	*/
	private static void debug(String format, Object... args) {
	// Reserved for future logging
	}

	/**
	* Log a serious unexpected internal exception.
	*
	* @param ex the exception
	* @param where a description of the context of the exception
	*/
	private static void debug(Throwable ex, String where) {
	// Reserved for future logging
	}

	}