jdk-sandbox: comparison test/hotspot/jtreg/vmTestbase/nsk/share/jpda/SocketConnection.java

equal deleted inserted replaced

-:c63bdf53a1a7
+:44839fbb20db
+/*
+* Copyright (c) 2001, 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.
+*/
+package nsk.share.jpda;
+import java.io.*;
+import java.net.*;
+import nsk.share.*;
+/**
+* This class implements basic connection channel via TCP/IP sockets.
+*/
+class BasicSocketConnection {
+protected static int TRACE_LEVEL_PACKETS = 10;
+protected static int TRACE_LEVEL_THREADS = 20;
+protected static int TRACE_LEVEL_ACTIONS = 30;
+protected static int TRACE_LEVEL_SOCKETS = 40;
+protected static int TRACE_LEVEL_IO = 50;
+protected String name = null;
+protected ServerSocket serverSocket = null;
+protected Socket socket = null;
+protected InputStream sin = null;
+protected OutputStream sout = null;
+protected Process connectingProcess = null;
+protected volatile boolean connected = false;
+protected volatile boolean closed = false;
+protected volatile boolean connectionClosed = false;
+protected volatile boolean shouldStop = false;
+protected Log.Logger logger = null;
+/**
+* Make an empty connection with specified name.
+*
+* @param logger
+*                Logger object for printing log messages
+* @param name
+*                connection name
+*/
+public BasicSocketConnection(Log.Logger logger, String name) {
+this.logger = logger;
+this.name = name;
+}
+/**
+* Try to bind connection to the local port.
+*
+* @param port
+*                port number to bind to
+*
+* @throws IOException
+*                 if error occured while binding
+*/
+protected void tryBind(int port) throws IOException {
+logger.trace(TRACE_LEVEL_IO, "Binding for " + name + " connection to port: " + port);
+serverSocket = new ServerSocket(port, 1);
+logger.trace(TRACE_LEVEL_IO, "Bound for " + name + " connection to port: " + port);
+}
+/**
+* Bind connection to the local port for specified timeout.
+*
+* @param port
+*                port number to bind to
+* @param timeout
+*                binding timeout in milliseconds
+*
+* @throws Failure
+*                 if error ocured while binding
+*/
+protected void bind(int port, long timeout) {
+BindException bindException = null;
+long timeToFinish = System.currentTimeMillis() + timeout;
+for (long i = 0; !shouldStop && (timeout == 0 || System.currentTimeMillis() < timeToFinish); i++) {
+try {
+tryBind(port);
+return;
+} catch (BindException e) {
+bindException = e;
+logger.display("Attempt #" + i + " to bind to port " + port + " failed:\n\t" + e);
+try {
+Thread.sleep(DebugeeBinder.CONNECT_TRY_DELAY);
+} catch (InterruptedException ie) {
+ie.printStackTrace(logger.getOutStream());
+throw new Failure("Thread interrupted while binding for " + name + " connection to port " + port + ":\n\t" + ie);
+}
+} catch (IOException e) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught IOException while binding for " + name + " connection to port " + port + ":\n\t" + e);
+}
+}
+throw new Failure("Unable to bind for " + name + " connection to port " + port + " for " + timeout + "ms timeout:\n\t" + bindException);
+}
+/**
+* Accept connection at the bound port for specified timeout.
+*
+* @param timeout
+*                accepting timeout in milliseconds
+*
+* @throws Failure
+*                 if error occured while accepting connection
+*/
+public void accept(long timeout) {
+int port = serverSocket.getLocalPort();
+logger.trace(TRACE_LEVEL_IO, "Listening for " + name + " connection at port: " + port);
+socket = null;
+try {
+if (timeout > Integer.MAX_VALUE) {
+throw new TestBug("Too large timeout long value: " + timeout + " (can't cast it to int)");
+}
+serverSocket.setSoTimeout((int)timeout);
+long waitStartTime = System.currentTimeMillis();
+/*
+* We found that sometimes (very rarely) on Solaris ServerSocket.accept() throws InterruptedIOException
+* even if connection timeout (specified through ServerSocket.setSoTimeout) didn't expire.
+* Following code tries to catch such case and call ServerSocket.accept() while timeout didn't expire.
+*/
+do {
+try {
+socket = serverSocket.accept();
+logger.trace(TRACE_LEVEL_IO, "Accepted " + name + " connection at port: " + port);
+} catch (InterruptedIOException e) {
+long interruptTime = System.currentTimeMillis();
+long waitTime = interruptTime - waitStartTime;
+logger.display("Caught InterruptedIOException. Wait start time: " + waitStartTime + ", exception was thrown at: "
++ interruptTime + ", wait time: " + (interruptTime - waitStartTime) + ", actual timeout: " + timeout);
+// if waitTime was too small call ServerSocket.accept() one more time
+if (!shouldStop && (waitTime < (timeout / 2))) {
+logger.display("InterruptedIOException was thrown too early, trying to call ServerSocket.accept() one more time");
+continue;
+} else {
+if (!shouldStop) {
+logger.complain("Caught InterruptedIOException while listening for " + name + " connection at port " + port + ":\n\t" + e);
+throw new Failure("Connection for " + name +
+" at port " + port +
+" wasn't accepted in " + timeout + "ms");
+} else {
+logger.display("Listening was interrupted (caught InterruptedIOException while listening for " + name + " connection at port " + port + ":\n\t" + e + ")");
+break;
+}
+}
+}
+} while (socket == null);
+} catch (IOException e) {
+if (!shouldStop) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught IOException while listening for " + name + " connection at port " + port + ":\n\t" + e);
+} else {
+logger.display("Listening was interrupted (caught InterruptedIOException while listening for " + name + " connection at port " + port + ":\n\t" + e + ")");
+}
+} finally {
+closeServerConnection();
+}
+if (!shouldStop) {
+if (socket == null) {
+throw new Failure("No " + name + " connection accepted at port " + port + " for " + timeout + "ms timeout");
+}
+onConnected();
+}
+}
+/**
+* Attach connection to the remote host and port.
+*
+* @param host
+*                name of remote host to attach to
+* @param port
+*                port number to attach to
+*
+* @throws Failure
+*                 if error occured while attaching
+*/
+public void attach(String host, int port) {
+try {
+logger.trace(TRACE_LEVEL_IO, "Attaching for " + name + " connection to host: " + host + ":" + port);
+socket = new Socket(host, port);
+socket.setTcpNoDelay(true);
+logger.trace(TRACE_LEVEL_IO, "Attached for " + name + " connection to host: " + host + ":" + port);
+} catch (IOException e) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught IOException while attaching for " + name + " connection to " + host + ":" + port + ":\n\t" + e);
+}
+if (!shouldStop) {
+onConnected();
+}
+}
+/**
+* Continuously attach to the remote host for the specified timeout.
+*
+* @param host
+*                name of remote host to attach to
+* @param port
+*                port number to attach to
+* @param timeout
+*                attaching timeout in milliseconds
+*
+* @throws Failure
+*                 if error occured while attaching
+*/
+public void continueAttach(String host, int port, long timeout) {
+socket = null;
+long timeToFinish = System.currentTimeMillis() + timeout;
+ConnectException lastException = null;
+logger.trace(TRACE_LEVEL_IO, "Attaching for " + name + " connection to host: " + host + ":" + port);
+try {
+for (long i = 0; !shouldStop && (timeout == 0 || System.currentTimeMillis() < timeToFinish); i++) {
+try {
+socket = new Socket(host, port);
+logger.trace(TRACE_LEVEL_IO, "Attached for " + name + " connection to host: " + host + ":" + port);
+break;
+} catch (ConnectException e) {
+logger.display("Attempt #" + i + " to attach for " + name + " connection failed:\n\t" + e);
+lastException = e;
+// check if listening process still alive
+if (!checkConnectingProcess()) {
+shouldStop = true;
+throw new Failure("Break attaching to " + name + " connection: " + "listening process exited");
+}
+// sleep between attempts
+try {
+Thread.sleep(DebugeeBinder.CONNECT_TRY_DELAY);
+} catch (InterruptedException ie) {
+throw new Failure("Thread interrupted while attaching for " + name + " connection to " + host + ":" + port + ":\n\t" + ie);
+}
+}
+}
+} catch (IOException e) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught IOException while attaching for " + name + " connection to " + host + ":" + port + ":\n\t" + e);
+}
+if (!shouldStop) {
+if (socket == null) {
+throw new Failure("Unable to attach for " + name + " connection to " + host + ":" + port + " for " + timeout + "ms timeout:\n\t"
++ lastException);
+}
+onConnected();
+}
+}
+/**
+* Set already bound serverSocket for further connection.
+*/
+public void setServerSocket(ServerSocket serverSocket) {
+this.serverSocket = serverSocket;
+}
+/**
+* Set already connected socket for connection.
+*/
+public void setSocket(Socket socket) {
+this.socket = socket;
+if (!shouldStop) {
+onConnected();
+}
+}
+/**
+* Get socket of already established connection.
+*/
+public Socket getSocket() {
+return socket;
+}
+/**
+* Return true if another connecting process is still alive.
+*/
+public boolean checkConnectingProcess() {
+if (connectingProcess == null) {
+// no process to check
+return true;
+}
+try {
+int exitCode = connectingProcess.exitValue();
+} catch (IllegalThreadStateException e) {
+// process is still alive
+return true;
+}
+// process exited
+return false;
+}
+/**
+* Set another connecting process to control if it is still alive.
+*/
+public void setConnectingProcess(Process process) {
+connectingProcess = process;
+}
+/**
+* Check if connection is established.
+*/
+public boolean isConnected() {
+return connected;
+}
+/**
+* Close socket and associated streams.
+*/
+public void close() {
+if (!closed) {
+shouldStop = true;
+closeConnection();
+closed = true;
+}
+}
+/**
+* Send the specified byte throw the connection.
+*/
+public void writeByte(byte b) throws IOException {
+logger.trace(TRACE_LEVEL_IO, "Writing byte: " + b);
+sout.write(b);
+sout.flush();
+logger.trace(TRACE_LEVEL_IO, "Wrote byte: " + b);
+}
+/**
+* Read a byte and return it or -1.
+*/
+public int readByte() throws IOException {
+logger.trace(TRACE_LEVEL_IO, "Reading byte");
+int b = sin.read();
+logger.trace(TRACE_LEVEL_IO, "Received byte: " + b);
+return b;
+}
+/**
+* Perform some actions after connection established.
+*/
+protected void onConnected() {
+if (!shouldStop) {
+setSocketOptions();
+makeSocketStreams();
+connected = true;
+}
+}
+/**
+* Set socket options after connection established.
+*/
+protected void setSocketOptions() {
+}
+/**
+* Close server socket.
+*/
+protected void closeServerConnection() {
+if (serverSocket != null) {
+try {
+serverSocket.close();
+logger.trace(TRACE_LEVEL_IO, "ServerSocket closed: " + serverSocket);
+} catch (IOException e) {
+logger.display("# WARNING: " + "Caught IOException while closing ServerSocket of " + name + " connection:\n\t" + e);
+}
+}
+}
+/**
+* Close socket of connection to remote host.
+*/
+protected void closeHostConnection() {
+if (socket != null) {
+try {
+socket.close();
+logger.trace(TRACE_LEVEL_IO, "Socket closed: " + socket);
+} catch (IOException e) {
+logger.display("# WARNING: " + "Caught IOException while closing socket of " + name + " connection:\n\t" + e);
+}
+}
+}
+/**
+* Close socket streams.
+*/
+protected void closeSocketStreams() {
+if (sout != null) {
+try {
+logger.trace(TRACE_LEVEL_IO, "Closing socket output stream: " + sout);
+sout.close();
+logger.trace(TRACE_LEVEL_IO, "Output stream closed: " + sout);
+} catch (IOException e) {
+logger.display("# WARNING: " + "Caught IOException while closing OutputStream of " + name + " connection:\n\t" + e);
+}
+}
+if (sin != null) {
+try {
+logger.trace(TRACE_LEVEL_IO, "Closing socket input stream: " + sin);
+sin.close();
+logger.trace(TRACE_LEVEL_IO, "Input stream closed: " + sin);
+} catch (IOException e) {
+logger.display("# WARNING: " + "Caught IOException while closing InputStream of" + name + " connection:\n\t" + e);
+}
+}
+}
+/**
+* Close sockets and associated streams.
+*/
+protected void closeConnection() {
+if (connectionClosed)
+return;
+logger.trace(TRACE_LEVEL_IO, "Closing " + name + " connection");
+closeSocketStreams();
+closeHostConnection();
+closeServerConnection();
+connectionClosed = true;
+}
+/**
+* Make up socket streams after connection established.
+*/
+protected void makeSocketStreams() {
+try {
+logger.trace(TRACE_LEVEL_IO, "Getting input/output socket streams for " + name + " connection");
+sout = socket.getOutputStream();
+logger.trace(TRACE_LEVEL_IO, "Got socket output stream: " + sout);
+sin = socket.getInputStream();
+logger.trace(TRACE_LEVEL_IO, "Got socket input stream: " + sin);
+} catch (IOException e) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught exception while making streams for " + name + " connection:\n\t" + e);
+}
+}
+} // BasicSocketConnection
+/**
+* This class implements connection channel via TCP/IP sockets. After connection
+* established special inner threads are started, which periodically test the
+* connection by pinging each other. If ping timeout occurs connection is closed
+* and any thread waiting for read from this connection gets exception.
+*
+* @see #setPingTimeout(long)
+*/
+public class SocketConnection extends BasicSocketConnection {
+private static final long PING_INTERVAL = 1 * 1000; // milliseconds
+private static byte DATA_BYTE = (byte) 0x03;
+private static byte DISCONNECT_BYTE = (byte) 0x04;
+private final Object inLock = new Object();
+private ObjectInputStream in = null;
+private final Object outLock = new Object();
+private ObjectOutputStream out = null;
+private volatile long pingTimeout = 0; // don't use ping
+/**
+* Make an empty connection with specified name.
+*
+* @param log
+*                Log object for printing log messages
+* @param name
+*                connection name
+*/
+public SocketConnection(Log log, String name) {
+this(new Log.Logger(log, name + " connection> "), name);
+}
+/**
+* Make an empty connection with specified name.
+*
+* @param logger
+*                Logger object for printing log messages
+* @param name
+*                connection name
+*/
+public SocketConnection(Log.Logger logger, String name) {
+super(logger, name);
+}
+/**
+* Set ping timeout in milliseconds (0 means don't use ping at all).
+*/
+public void setPingTimeout(long timeout) {
+logger.display("# WARNING: Setting ping timeout for " + name + " connection ingnored: " + timeout + " ms");
+pingTimeout = timeout;
+}
+/**
+* Returns value of current ping timeout in milliseconds (0 means ping is
+* not used).
+*/
+public long getPingTimeout() {
+return pingTimeout;
+}
+/**
+* Receive an object from remote host.
+*/
+public Object readObject() {
+if (!isConnected()) {
+throw new Failure("Unable to read object from not established " + name + " connection");
+}
+try {
+return doReadObject();
+} catch (EOFException e) {
+return null;
+} catch (Exception e) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught Exception while reading an object from " + name + " connection:\n\t" + e);
+}
+}
+/**
+* Send an object to remote host.
+*/
+public void writeObject(Object object) {
+if (!isConnected()) {
+throw new Failure("Unable to send object throw not established " + name + " connection:\n\t" + object);
+}
+try {
+doWriteObject(object);
+} catch (IOException e) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught IOException while writing an object to " + name + " connection:\n\t" + e);
+}
+}
+/**
+* Close socket and associated streams and finish all internal threads.
+*/
+public void close() {
+if (!closed) {
+// disconnect();
+shouldStop = true;
+super.close();
+closed = true;
+}
+}
+/**
+* Perform some actions after connection has established.
+*/
+protected void onConnected() {
+super.onConnected();
+}
+/**
+* Do write an object to the connection channel.
+*/
+private void doWriteObject(Object object) throws IOException {
+logger.trace(TRACE_LEVEL_IO, "writing object: " + object);
+synchronized(outLock) {
+out.writeObject(object);
+out.flush();
+}
+logger.trace(TRACE_LEVEL_PACKETS, "* sent: " + object);
+}
+/**
+* Do read an object from the connection channel.
+*/
+private Object doReadObject() throws IOException, ClassNotFoundException {
+logger.trace(TRACE_LEVEL_IO, "Reading object");
+Object object = null;
+synchronized(inLock) {
+object = in.readObject();
+}
+logger.trace(TRACE_LEVEL_PACKETS, "* recv: " + object);
+return object;
+}
+/**
+* Close socket streams.
+*/
+protected void closeSocketStreams() {
+synchronized(outLock) {
+if (out != null) {
+try {
+logger.trace(TRACE_LEVEL_IO, "Closing socket output stream: " + out);
+out.close();
+logger.trace(TRACE_LEVEL_IO, "Output stream closed: " + out);
+} catch (IOException e) {
+logger.display("# WARNING: " + "Caught IOException while closing ObjectOutputStream of " + name + " connection:\n\t" + e);
+}
+}
+}
+synchronized(inLock) {
+if (in != null) {
+try {
+logger.trace(TRACE_LEVEL_IO, "Closing socket input stream: " + in);
+in.close();
+logger.trace(TRACE_LEVEL_IO, "Input stream closed: " + in);
+} catch (IOException e) {
+logger.display("# WARNING: " + "Caught IOException while closing ObjectInputStream of" + name + " connection:\n\t" + e);
+}
+}
+}
+super.closeSocketStreams();
+}
+/**
+* Close sockets and associated streams.
+*/
+protected void closeConnection() {
+if (connectionClosed)
+return;
+connected = false;
+shouldStop = true;
+super.closeConnection();
+}
+/**
+* Make up object streams for socket.
+*/
+protected void makeSocketStreams() {
+try {
+logger.trace(TRACE_LEVEL_IO, "Making input/output object streams for " + name + " connection");
+synchronized(outLock) {
+out = new ObjectOutputStream(socket.getOutputStream());
+out.flush();
+}
+logger.trace(TRACE_LEVEL_IO, "Output stream created: " + out);
+synchronized(inLock) {
+in = new ObjectInputStream(socket.getInputStream());
+}
+logger.trace(TRACE_LEVEL_IO, "Input stream created: " + in);
+} catch (IOException e) {
+e.printStackTrace(logger.getOutStream());
+throw new Failure("Caught exception while making streams for " + name + " connection:\n\t" + e);
+}
+}
+} // SocketConnection