process.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <sys/types.h>
#include <promeki/core/namespace.h>
#include <promeki/core/platform.h>
#include <promeki/core/objectbase.h>
#include <promeki/core/string.h>
#include <promeki/core/list.h>
#include <promeki/core/map.h>
#include <promeki/core/buffer.h>
#include <promeki/core/filepath.h>
#include <promeki/core/error.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Process : public ObjectBase {
        PROMEKI_OBJECT(Process, ObjectBase)
        public:
                enum State {
                        NotRunning = 0,  
                        Starting,        
                        Running          
                };
 
                Process(const Process &) = delete;
                Process &operator=(const Process &) = delete;
 
                Process(ObjectBase *parent = nullptr);
 
                ~Process();
 
                const String &program() const { return _program; }
 
                void setProgram(const String &program) { _program = program; }
 
                const List<String> &arguments() const { return _arguments; }
 
                void setArguments(const List<String> &args) { _arguments = args; }
 
                const FilePath &workingDirectory() const { return _workingDirectory; }
 
                void setWorkingDirectory(const FilePath &dir) { _workingDirectory = dir; }
 
                const Map<String, String> &environment() const { return _environment; }
 
                void setEnvironment(const Map<String, String> &env) { _environment = env; }
 
                Error start();
 
                Error start(const String &program, const List<String> &args);
 
                Error waitForStarted(unsigned int timeoutMs = 0);
 
                Error waitForFinished(unsigned int timeoutMs = 0);
 
                int exitCode() const { return _exitCode; }
 
                bool isRunning() const { return _state == Running; }
 
                State state() const { return _state; }
 
                pid_t pid() const { return _pid; }
 
                void kill();
 
                void terminate();
 
                ssize_t writeToStdin(const void *buf, size_t bytes);
 
                Buffer readAllStdout();
 
                Buffer readAllStderr();
 
                void closeWriteChannel();
 
                PROMEKI_SIGNAL(started);
 
                PROMEKI_SIGNAL(finished, int);
 
                PROMEKI_SIGNAL(readyReadStdout);
 
                PROMEKI_SIGNAL(readyReadStderr);
 
                PROMEKI_SIGNAL(errorOccurred, Error);
 
        private:
                String                  _program;
                List<String>            _arguments;
                FilePath                _workingDirectory;
                Map<String, String>     _environment;
                State                   _state = NotRunning;
                pid_t                   _pid = -1;
                int                     _exitCode = -1;
                int                     _stdinPipe[2]  = {-1, -1};
                int                     _stdoutPipe[2] = {-1, -1};
                int                     _stderrPipe[2] = {-1, -1};
                List<Buffer>            _stdoutChunks;
                List<Buffer>            _stderrChunks;
                size_t                  _stdoutTotal = 0;
                size_t                  _stderrTotal = 0;
 
                void closeFd(int &fd);
 
                void closeAllPipes();
 
                void drainFd(int &fd, List<Buffer> &chunks, size_t &total);
 
                void drainPipes();
 
                Buffer assembleChunks(List<Buffer> &chunks, size_t &total);
 
                bool collectExitStatus();
};
 
PROMEKI_NAMESPACE_END