如何在此处正确关闭 ssh 连接/会话？

Question

I have a client/server socket program. Server part is connecting via ssh to a host, runs a script, and sends each line of the output to the client.

The below server code part returns a BufferedReader containing the script output as it happens:

public synchronized BufferedReader runScript(<params>) {    
  BufferedReader br = null ;
  try {
      Connection conn = new Connection(host);
      conn.connect();
      ... // authentication part
      Session sess = conn.openSession();
      sess.execCommand("ascript");
      InputStream stdout = new StreamGobbler(sess.getStdout());
      br = new BufferedReader(new InputStreamReader(stdout));
  } catch (Exception e) {
      e.printStackTrace();
  }
  return br;
}

The above method is called from another server-side class/code as below, writing each line of the BufferedReader to the client through a socket, so that client sees the live output of the script as it runs :

BufferedReader br = new UnixCommandExecutor().runScript(<params>);
String line;
while ((line = br.readLine()) != null) {
      out.writeObject(line);
}

The obvious problem with runScript method is that it doesn't close the ssh Connection & Session (ganymed ssh lib), as it instantly returns the BufferedReader (if I'm not mistaken) while the underlying script still runs . If I close these before the return statement, the BufferedReader would be incomplete. So how do I properly close connection/session here as soon as the underlying script completes ?

(I'm aware of try-with-resources and will use it, however I doubt it will solve the problem completely?)

Answer 1

I would suggest that you refactor the code, so that you

• either wrap the parts into an object and handling the close operation later
• or you consume the Reader immediately and close the connection after you are done with it.

Do not pass the Reader to the outside without maintaining the connection.

Below a somewhat simplified example on how it could be done.

If you need to process through mutliple steps before your are done with the Reader, you might not be able to wrap the ResultHandler in a try { ... } catch block. In that case you need a different meachnism to ensure that this will eventually be closed.

But judging from your problem description that might not be the case.

If you do not want to block till the operation is done (anyway this operation is something that should be executed in a background thread), then you probably want to send each output line you receive to somewhere where it can be displayed. In this case you can should provide an interface that you use to forward the received lines.

While the reader still receives output (as long as the input stream / connection is active) you`ll probably need to loop. Somehow you need to figure out when your operation is completed.

For example your script could close the connection (from the serverside) once it is done or return something specific to you that you can interpret as end of operations.

public class ResultHandler {

    String host;
    Connection conn;
    BufferedReader reader = null;

    public ResultReader(String host) {
        this.host = host;
    }

    public void connect(<params>) throws Exception {

        // if you intend to reuse the object, just check that it was properly cleanedup before
        close();

        conn = new Connection(host);
        conn.connect();
        ... // authentication part

        // you might want to move the actual handling to a different method
        Session sess = conn.openSession();
        sess.execCommand("ascript");
        InputStream stdout = new StreamGobbler(sess.getStdout());
        br = new BufferedReader(new InputStreamReader(stdout));
    }

    public BufferedReader getReader() {
        return this.reader;
    }

    public void close() {
        If (reader != null) {
            reader.close();
        }
        if (conn != null) {
            conn.close();
        }
    }

    public void finalize() {
        close();
    }
}


synchronized void runScript(<params>) {    

  ResultHandler handler;
  try {
        handler = new ResultHandler(host);
        handler.connect();

        // consume the reader for whatever you need to do

  } catch (Exception e) {
      e.printStackTrace();
  } finally {
    // or use try-with-resource and implement the proper interface for that
    if (handler != null) {
        handler.close();
     }
  }
}