Nano, in Shell Access 2, A Technical How-To

Given that it took me quite a while to figure out a way to make this happen, I'd like to share the solution that we have created for Coalevo (and KaraNet) to be able to edit messages using a GNU nano editor from within the Java based Coalevo platform (specifically the shell access).

Essentially, there are three key points that make it possible:
First, the ProcessBuilder, that helps to create and run a process from within the JVM
Second, handling the Streams and pumping the I/O between the JVM and the process
Third, tricking Linux into running nano as if a terminal is available

There is no big deal about the first part, actually its relatively easy to create a ProcessBuilder instance with a command, add environment variables and start a process:

      //Prepare command
      List l = new ArrayList();
      l.add(System.getProperty(NANO_SYS_PROP));
      l.add("-R");
      if(m_Shell.getSession().isRebindDelete()) {
        l.add("-d");
      }
      l.add(m_File.getAbsolutePath());
      ProcessBuilder pb = new ProcessBuilder(l);

      //Prepare environment
      Map env = pb.environment();
      env.put("COLUMNS", Integer.toString(m_Shell.getShellIO().getColumns()));
      env.put("LINES", Integer.toString(m_Shell.getShellIO().getRows()));

      //Start Process
      m_Process = pb.start();

The second part is a little bit trickier. There are several approaches to this, but given that there is already one thread per user connection running, we decided to use this thread to pump the streams and take an approach (kudos for this one to gnodet from the Apache Mina project).

      //Prepare connection streams
      m_Input = m_Shell.getShellIO().getTerminalIO().getBaseIO().getInputStream();
      m_Output = m_Shell.getShellIO().getTerminalIO().getBaseIO().getOutputStream();

      //Acquire process streams
      m_ProcessInput = m_Process.getInputStream();
      m_ProcessOutput = m_Process.getOutputStream();
      m_ProcessError = m_Process.getErrorStream();

     //start pumping
      pumpStreams();

Here is how the pumping mechanism works:

  private boolean pumpStream(InputStream in, OutputStream out, byte[] buffer) throws IOException {
    if (in.available() > 0) {
      int len = in.read(buffer);
      if (len > 0) {
        out.write(buffer, 0, len);
        out.flush();
        return true;
      }
    }
    return false;
  }//pumpStream

 private void pumpStreams() {
    try {
      for (; ;) {
        if (!isAlive()) {
          return;
        }
        if (pumpStream(m_Input, m_ProcessOutput, m_Buffer)) {
          continue;
        }
        if (pumpStream(m_ProcessInput, m_Output, m_Buffer)) {
          continue;
        }
        if (pumpStream(m_ProcessError, m_Output, m_Buffer)) {
          continue;
        }
        // Sleep a bit.  This is not very good, as it consumes CPU, but the
        // input streams are not selectable for nio, and any other blocking
        // method would consume at least two threads
        Thread.sleep(1);
      }
    } catch (Exception e) {
      m_Process.destroy();
    }
  }//pumpStreams

The third part is actually not necessary on Darwin/OS X, where the process from the JVM seems to be already providing a terminal. However, it is necessary on Linux for standard JVMs. Kudos for this trick goes to Mitch; its essentially running nano through a local relay called socat:

#/bin/bash
export LANG=en_US.utf8
socat - EXEC:"/home/coalevo/nano $*",pty,stderr

Last but not least, the nano we are using has been slightly hacked, and is always started in a restricted mode (-R flag).

For the complete picture, we suggest to check out the EmbeddedNano source code.