JProcess.hh

Go to the documentation of this file.

#ifndef __JSYSTEM__JPROCESS__
#define __JSYSTEM__JPROCESS__
 
#include <unistd.h>
 
#include "JLang/JException.hh"
#include "JLang/JFileStreamBuffer.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JSYSTEM {}
namespace JPP { using namespace JSYSTEM; }
 
namespace JSYSTEM {
 
  using JLANG::JPipeOpenException;
  using JLANG::JForkException;
  using JLANG::JSystemException;
  using JLANG::JFileInputStreamBuffer;
  using JLANG::JFileOutputStreamBuffer;
 
 
  /**
   * Streaming of input and output from Linux command.
   */
  class JProcess 
  {   
  public:
    /**
     * Default constructor.
     * This constructor starts an interactive shell.
     */
    JProcess() :
      out (-1),
      err (-1),
      in  (-1),
      gOut(NULL),
      gErr(NULL),
      gIn (NULL)
    { 
      execute("/bin/tcsh", "tcsh", "-i", "-f");
    }
 
 
    /**
     * Constructor.
     *
     * \param  command         Linux command
     */
    JProcess(const std::string& command) :
      out (-1),
      err (-1),
      in  (-1),
      gOut(NULL),
      gErr(NULL),
      gIn (NULL)
    { 
      execute("/bin/tcsh", "tcsh", "-f", "-c", command.c_str());
    }
 
 
    /**
     * Destructor.
     */
    ~JProcess()
    {
      close(err);
      close(out);
      close(in);
 
      if (gOut != NULL) { delete gOut; }
      if (gErr != NULL) { delete gErr; }
      if (gIn  != NULL) { delete gIn;  }
    }
 
 
    /**
     * Get pointer to input stream buffer connected to the normal output stream.
     *
     * \param  size            size of internal buffers
     * \return                 pointer input stream buffer
     */
    JFileInputStreamBuffer* getInputStreamBuffer(const std::size_t size = 65536)
    {
      if (gOut == NULL) {
        gOut = new JFileInputStreamBuffer(out, size);
      }
 
      return gOut;
    }
 
 
    /**
     * Get pointer to input stream buffer connected to the error output stream.
     *
     * \param  size            size of internal buffers
     * \return                 pointer to input stream buffer
     */
    JFileInputStreamBuffer* getErrorStreamBuffer(const std::size_t size = 65536)
    {
      if (gErr == NULL) {
        gErr = new JFileInputStreamBuffer(err, size);
      }
 
      return gErr;
    }
 
 
    /**
     * Get pointer to output stream buffer connected to the normal input stream.
     *
     * \param  size            size of internal buffers
     * \return                 pointer to output stream buffer
     */
    JFileOutputStreamBuffer* getOutputStreamBuffer(const std::size_t size = 65536)
    {
      if (gIn == NULL) {
        gIn = new JFileOutputStreamBuffer(in, size);
      }
 
      return gIn;
    }
 
  protected:
    /**
     * Execute command.
     *
     * \param  path            path
     * \param  arg0            comma separted argument list
     * \param  arg1            comma separted argument list
     * \param  arg2            comma separted argument list
     * \param  arg3            comma separted argument list
     * \param  arg4            comma separted argument list
     * \param  arg5            comma separted argument list
     * \param  arg6            comma separted argument list
     * \param  arg7            comma separted argument list
     * \param  arg8            comma separted argument list
     * \param  arg9            comma separted argument list
     */
    void execute(const char* path, 
                 const char* arg0,
                 const char* arg1 = (char*) NULL,
                 const char* arg2 = (char*) NULL,
                 const char* arg3 = (char*) NULL,
                 const char* arg4 = (char*) NULL,
                 const char* arg5 = (char*) NULL,
                 const char* arg6 = (char*) NULL,
                 const char* arg7 = (char*) NULL,
                 const char* arg8 = (char*) NULL,
                 const char* arg9 = (char*) NULL)
    {
      int pipe_stdin [2];
      int pipe_stdout[2];
      int pipe_stderr[2];
 
      if (pipe(pipe_stdin))  { THROW(JPipeOpenException, "Error at pipe of standard input.");  }
      if (pipe(pipe_stdout)) { THROW(JPipeOpenException, "Error at pipe of standard output."); }
      if (pipe(pipe_stderr)) { THROW(JPipeOpenException, "Error at pipe of standard error.");  }
      
      const pid_t pid = fork();
 
      if (pid < 0) 
 
        // error
 
        THROW(JForkException, "JProcess::fork() failed");
 
      else if (pid == 0) {
 
        // child
 
        close(pipe_stdin [1]);
        if (dup2 (pipe_stdin [0], STDIN_FILENO)  == -1) { JSystemException("dup2-stdin"); }
 
        close(pipe_stdout[0]);
        if (dup2 (pipe_stdout[1], STDOUT_FILENO) == -1) { JSystemException("dup2-stdout"); }
 
        close(pipe_stdout[0]);
        if (dup2 (pipe_stdout[1], STDERR_FILENO) == -1) { JSystemException("dup2-stderr"); }
 
        execl(path, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, (char*) NULL);
 
        THROW(JSystemException, path);
 
      } else {
 
        // parent
 
        in  = pipe_stdin [1];
        out = pipe_stdout[0];
        err = pipe_stderr[0];
 
        close(pipe_stdin [0]);
        close(pipe_stdout[1]);
        close(pipe_stderr[1]);
      }
    }
 
    int out;
    int err;
    int in;
 
  private:
    JFileInputStreamBuffer*  gOut;
    JFileInputStreamBuffer*  gErr;
    JFileOutputStreamBuffer* gIn;
 
    JProcess(const JProcess&);
    JProcess(JProcess&&);
    JProcess& operator=(const JProcess&);
    JProcess& operator=(JProcess&&);
  };  
}
 
#endif