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 Run {
    friend class RunPump;
  public:
    // Interface to container for data received/sent to process.
    class Data {
     public:
      virtual ~Data() {};
      virtual void Append(char const* data, unsigned int size) = 0;
      virtual void Remove(unsigned int size) = 0;
      virtual char const* Get() const = 0;
      virtual unsigned int Size() const = 0;
    };

  private:
    Run(const Run&);
    Run& operator=(Run&);
  protected:
    // Container for data pumped through std* channels.
    class StringData: public Data {
     public:
      StringData();
      virtual ~StringData();
      void Assign(std::string& str, int content_max_size = 0);
      virtual void Append(char const* data, unsigned int size);
      virtual void Remove(unsigned int size);
      virtual char const* Get() const;
      virtual unsigned int Size() const;
     private:
      std::string* content_;
      int content_max_size_;
    };

    // working directory
    std::string working_directory;
    // Std* handles
    int stdout_;
    int stderr_;
    int stdin_;
    // Associated string containers
    Data *stdout_str_;
    Data *stderr_str_;
    Data *stdin_str_;
    StringData stdout_str_wrap_;
    StringData stderr_str_wrap_;
    StringData stdin_str_wrap_;
    // Request to keep std* handles of process same as in parent
    bool stdout_keep_;
    bool stderr_keep_;
    bool stdin_keep_;
    // PID of child
    pid_t pid_;
    // Arguments to execute
    std::list<std::string> argv_;
    std::list<std::string> envp_;
    std::list<std::string> envx_;
    void (*initializer_func_)(void*);
    void *initializer_arg_;
    void (*kicker_func_)(void*);
    void *kicker_arg_;
    // IO handlers are called when data can be sent/received
    typedef bool (Run::*HandleHandler)();
    bool stdout_handler();
    bool stderr_handler();
    bool stdin_handler();
    // Child exit handler
    typedef bool (Run::*PidHandler)(int);
    void child_handler(int result);
    bool started_; // child process was stated
    bool running_; // child process is running
    bool abandoned_; // we are interested in this process anymore
    int result_; // process execution 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, int max_size = 102400);
    void AssignStdout(Data& str);

    void AssignStderr(std::string& str, int max_size = 102400);
    void AssignStderr(Data& str);

    void AssignStdin(std::string& str);
    void AssignStdin(Data& 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 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 AddEnvironment(const std::string& key, const std::string& value) {
      AddEnvironment(key+"="+value);
    }
    void AddEnvironment(const std::string& var) {
      envp_.push_back(var);
    }
    void RemoveEnvironment(const std::string& key) {
      envx_.push_back(key);
    }

    void Kill(int timeout);

    void Abandon(void);

    static void AfterFork(void);
  };

}

#endif // __ARC_RUN_H__