process.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <sys/types.h>
#include <promeki/namespace.h>
#include <promeki/platform.h>
#include <promeki/objectbase.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/buffer.h>
#include <promeki/filepath.h>
#include <promeki/error.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Process : public ObjectBase {
                PROMEKI_OBJECT(Process, ObjectBase)
        public:
                enum State {
                        NotRunning = 0, 
                        Starting,       
                        Running         
                };
 
                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
 
#endif // PROMEKI_ENABLE_CORE