AsyncExec.h

Go to the documentation of this file.

 
#ifndef ASYNC_EXEC_INCLUDED
#define ASYNC_EXEC_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <unistd.h>
#include <signal.h>
#include <sigc++/sigc++.h>
 
#include <vector>
#include <string>
#include <map>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncFdWatch.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
class Timer;
  
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class Exec : public sigc::trackable
{
  public:
    using Environment = std::vector<std::pair<std::string,std::string>>;
 
    explicit Exec(const std::string &cmdline="");
  
    ~Exec(void);
  
    void setCommandLine(const std::string &cmdline);
 
    const std::string &command(void) const { return args[0]; }
 
    void appendArgument(const std::string &arg);
 
    void clearEnvironment(void);
 
    void addEnvironmentVar(const std::string& name, const std::string& val);
 
    void addEnvironmentVars(const Environment& env);
 
    bool nice(int inc=10);
 
    void setTimeout(int time_s);
 
    bool run(void);
 
    bool writeStdin(const char *buf, int cnt);
 
    bool writeStdin(const std::string &str);
 
    bool kill(int sig=SIGTERM);
 
    bool closeStdin(void);
 
    bool ifExited(void) const;
 
    bool ifSignaled(void) const;
 
    int exitStatus(void) const;
 
    int termSig(void) const;
 
    sigc::signal<void, const char *, int> stdoutData;
 
    sigc::signal<void, const char *, int> stderrData;
 
    sigc::signal<void> stdoutClosed;
 
    sigc::signal<void> stderrClosed;
 
    sigc::signal<void> exited;
    
  protected:
    
  private:
    typedef std::map<pid_t, Exec*> ExecMap;
 
    static ExecMap            execs;
    static int                sigchld_pipe[2];
    static Async::FdWatch     *sigchld_watch;
    static struct sigaction   old_sigact;
 
    std::vector<std::string>  args;
    std::vector<std::string>  env;
    pid_t                     pid;
    Async::FdWatch            *stdout_watch;
    Async::FdWatch            *stderr_watch;
    int                       stdin_fd;
    int                       status;
    int                       nice_value;
    Async::Timer              *timeout_timer;
    bool                      pending_term;
    bool                      clear_env = false;
 
    static void handleSigChld(int signal_number, siginfo_t *info,
                              void *context);
    static void sigchldReceived(void);
 
    Exec(const Exec&);
    Exec& operator=(const Exec&);
    void stdoutActivity(Async::FdWatch *w);
    void stderrActivity(Async::FdWatch *w);
    void subprocessExited(void);
    void handleTimeout(void);
    
};  /* class Exec */
 
 
} /* namespace */
 
#endif /* ASYNC_EXEC_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */