/usr/include/arc/Run.h is in nordugrid-arc-dev 5.0.5-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | // -*- 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;
/// This class runs an external executable.
/** It is possible to read from or write to its standard handles or to
* redirect them to std::string elements.
* \ingroup common
* \headerfile Run.h arc/Run.h */
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:
/// Constructor prepares object to run cmdline.
Run(const std::string& cmdline);
/// Constructor prepares object to run executable and arguments specified in argv.
Run(const std::list<std::string>& argv);
/// Destructor kills running executable and releases associated resources.
~Run(void);
/// Returns true if object is valid.
operator bool(void) {
return argv_.size() != 0;
}
/// Returns true if object is invalid.
bool operator!(void) {
return argv_.size() == 0;
}
/// Starts running executable. This method may be called only once.
/** \return true if executable started without problems */
bool Start(void);
/// Wait till execution finished or till timeout seconds expires.
/** \return true if execution is complete. */
bool Wait(int timeout);
/// Wait till execution finished.
/** \return true if execution is complete, false if execution was not
started. */
bool Wait(void);
/// Returns exit code of execution.
/** If child process was killed then exit code is -1.
If code is compiled with support for detecting lost child
process this code is -1 also if track of child was lost. */
int Result(void) {
return result_;
}
/// Return true if execution is going on.
bool Running(void);
/// Return when executable was started.
Time RunTime(void) {
return run_time_;
};
/// Return when executable finished executing.
Time ExitTime(void) {
return exit_time_;
};
/// Read from stdout handle of running executable.
/** This method may be used while stdout is directed to string, but the
result is unpredictable.
\param timeout upper limit for which method will block in milliseconds.
Negative means infinite.
\param buf buffer to write the stdout to
\param size size of buf
\return number of read bytes. */
int ReadStdout(int timeout, char *buf, int size);
/// Read from stderr handle of running executable.
/** This method may be used while stderr is directed to string, but the
result is unpredictable.
\param timeout upper limit for which method will block in milliseconds.
Negative means infinite.
\param buf buffer to write the stderr to
\param size size of buf
\return number of read bytes. */
int ReadStderr(int timeout, char *buf, int size);
/// Write to stdin handle of running executable.
/** This method may be used while stdin is directed to string, but the
result is unpredictable.
\param timeout upper limit for which method will block in milliseconds.
Negative means infinite.
\param buf buffer to read the stdin from
\param size size of buf
\return number of written bytes. */
int WriteStdin(int timeout, const char *buf, int size);
/// Associate stdout handle of executable with string.
/** This method must be called before Start(). str object
must be valid as long as this object exists. */
void AssignStdout(std::string& str);
/// Associate stderr handle of executable with string.
/** This method must be called before Start(). str object
must be valid as long as this object exists. */
void AssignStderr(std::string& str);
/// Associate stdin handle of executable with string.
/** This method must be called before Start(). str object
must be valid as long as this object exists. */
void AssignStdin(std::string& str);
/// Keep stdout same as parent's if keep = true.
void KeepStdout(bool keep = true);
/// Keep stderr same as parent's if keep = true.
void KeepStderr(bool keep = true);
/// Keep stdin same as parent's if keep = true.
void KeepStdin(bool keep = true);
/// Closes pipe associated with stdout handle.
void CloseStdout(void);
/// Closes pipe associated with stderr handle.
void CloseStderr(void);
/// Closes pipe associated with stdin handle.
void CloseStdin(void);
//void DumpStdout(void);
//void DumpStderr(void);
/// Assign a function to be called just after process is forked but before execution starts.
void AssignInitializer(void (*initializer_func)(void*), void *initializer_arg);
/// Assign a function to be called just after execution ends
void AssignKicker(void (*kicker_func)(void*), void *kicker_arg);
/// Assign working directory of the running process.
void AssignWorkingDirectory(std::string& wd) {
working_directory = wd;
}
/// Assign uid for the process to run under.
void AssignUserId(int uid) {
user_id_ = uid;
}
/// Assign gid for the process to run under.
void AssignGroupId(int gid) {
group_id_ = gid;
}
/// Kill running executable.
/** First soft kill signal (SIGTERM) is sent to executable. If
after timeout seconds executable is still running it's killed
completely. Currently this method does not work for Windows OS */
void Kill(int timeout);
/// Detach this object from running process.
/** After calling this method instance is not associated with external
process anymore. As result destructor will not kill process. */
void Abandon(void);
/// Call this method after fork() in child process.
/** It will reinitialize internal structures for new environment. Do
not call it in any other case than defined. */
static void AfterFork(void);
};
}
#endif // __ARC_RUN_H__
|