Run.h

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_RUN_H__
#define __ARC_RUN_H__

#include <glibmm.h>
#include <arc/Thread.h>
#include <arc/DateTime.h>

namespace Arc {

  class RunPump;
  class Pid;


  class Run {
    friend class RunPump;
  private:
    Run(const Run&);
    Run& operator=(Run&);
  protected:
    // working directory
    std::string working_directory;
    // Handles
    int stdout_;
    int stderr_;
    int stdin_;
    // Associated string containers
    std::string *stdout_str_;
    std::string *stderr_str_;
    std::string *stdin_str_;
    //
    bool stdout_keep_;
    bool stderr_keep_;
    bool stdin_keep_;
    // Signal connections
    sigc::connection stdout_conn_;
    sigc::connection stderr_conn_;
    sigc::connection stdin_conn_;
    sigc::connection child_conn_;
    // PID of child
    Pid *pid_;
    // Arguments to execute
    Glib::ArrayHandle<std::string> argv_;
    void (*initializer_func_)(void*);
    void *initializer_arg_;
    void (*kicker_func_)(void*);
    void *kicker_arg_;
    // IO handlers
    bool stdout_handler(Glib::IOCondition cond);
    bool stderr_handler(Glib::IOCondition cond);
    bool stdin_handler(Glib::IOCondition cond);
    // Child exit handler
    void child_handler(Glib::Pid pid, int result);
    bool started_;
    bool running_;
    bool abandoned_;
    int result_;
    Glib::Mutex lock_;
    Glib::Cond cond_;
    int user_id_;
    int group_id_;
    Time run_time_;
    Time exit_time_;
  public:
    Run(const std::string& cmdline);
    Run(const std::list<std::string>& argv);
    ~Run(void);
    operator bool(void) {
      return argv_.size() != 0;
    }
    bool operator!(void) {
      return argv_.size() == 0;
    }

    bool Start(void);

    bool Wait(int timeout);

    bool Wait(void);

    int Result(void) {
      return result_;
    }
    bool Running(void);
    Time RunTime(void) {
      return run_time_;
    };
    Time ExitTime(void) {
      return exit_time_;
    };

    int ReadStdout(int timeout, char *buf, int size);

    int ReadStderr(int timeout, char *buf, int size);

    int WriteStdin(int timeout, const char *buf, int size);

    void AssignStdout(std::string& str);

    void AssignStderr(std::string& str);

    void AssignStdin(std::string& str);
    void KeepStdout(bool keep = true);
    void KeepStderr(bool keep = true);
    void KeepStdin(bool keep = true);
    void CloseStdout(void);
    void CloseStderr(void);
    void CloseStdin(void);
    //void DumpStdout(void);
    //void DumpStderr(void);
    void AssignInitializer(void (*initializer_func)(void*), void *initializer_arg);
    void AssignKicker(void (*kicker_func)(void*), void *kicker_arg);
    void AssignWorkingDirectory(std::string& wd) {
      working_directory = wd;
    }
    void AssignUserId(int uid) {
      user_id_ = uid;
    }
    void AssignGroupId(int gid) {
      group_id_ = gid;
    }

    void Kill(int timeout);

    void Abandon(void);

    static void AfterFork(void);
  };

}

#endif // __ARC_RUN_H__