ChildCloner.hxx

#pragma once
 
// C++
#include <functional>
#include <iosfwd>
#include <optional>
#include <string_view>
 
// cosmos
#include <cosmos/error/UsageError.hxx>
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/proc/Scheduler.hxx>
#include <cosmos/proc/SubProc.hxx>
#include <cosmos/string.hxx>
 
namespace cosmos {
 
 
class COSMOS_API ChildCloner {
public: // types
 
        typedef std::function<void (const ChildCloner&)> Callback;
 
public: // functions
 
        ChildCloner() = default;
 
 
        explicit ChildCloner(const StringViewVector args) {
                setArgsFromView(args);
        }
 
        bool hasExe() const { return !m_executable.empty(); }
 
        auto& getExe() { return m_executable; }
        const auto& getExe() const { return m_executable; }
 
 
        void setExe(const std::string_view exe) {
                m_executable = exe;
                setArgv0();
        }
 
 
        const auto& getArgs() const { return m_argv; }
 
        StringVector& getArgs() { return m_argv; }
 
 
        void setArgs(const StringVector &sv) {
                m_argv = sv;
                setExeFromArgv0();
        }
 
        void setArgsFromView(const StringViewVector &svv) {
                m_argv.clear();
                for (const auto s: svv)
                        m_argv.push_back(std::string{s});
                setExeFromArgv0();
        }
 
 
        void clearArgs() {
                if (m_argv.size() > 1) {
                        m_argv.erase(m_argv.begin() + 1);
                }
        }
 
 
        void setCWD(const std::string_view cwd) { m_cwd = cwd; }
 
        const auto& getCWD() const { return m_cwd; }
 
        void setInheritCWD() { m_cwd.clear(); }
 
 
        void setEnv(const StringVector &vars) { m_env = vars; }
 
        void setInheritEnv() { m_env.reset(); }
 
 
        void setStdErr(FileDescriptor fd) { m_stderr = fd; }
        void setStdOut(FileDescriptor fd) { m_stdout = fd; }
        void setStdIn(FileDescriptor fd) { m_stdin = fd; }
 
 
        void addInheritFD(FileDescriptor fd) {
                if (fd.raw() <= FileNum::STDERR) {
                        cosmos_throw(UsageError{"added stdio or invalid FD as extra inherit FD"});
                };
                m_inherit_fds.push_back(fd);
        }
 
 
        void resetStdFiles() {
                m_stderr.reset();
                m_stdin.reset();
                m_stdout.reset();
        }
 
 
        template <typename SCHED_SETTING>
        void setSchedulerSettings(const SCHED_SETTING &ss) { m_sched_settings = ss; };
 
        void setInheritSchedulerSettings() { m_sched_settings.reset(); }
 
 
        void setPostForkCB(Callback cb) { m_post_fork_cb = cb; }
 
        void resetPostForkCB() { m_post_fork_cb = nullptr; }
 
 
        SubProc run();
 
protected: // functions
 
        void postFork();
 
        void resetSignals();
 
 
        void redirectFD(FileDescriptor orig, FileDescriptor redirect);
 
        void setArgv0() {
                if (m_argv.empty())
                        m_argv.emplace_back(m_executable);
                else
                        m_argv[0] = m_executable;
        }
 
        void setExeFromArgv0() {
                if (m_argv.empty())
                        m_executable.clear();
                else
                        m_executable = m_argv[0];
        }
 
protected: // data
 
        std::string m_executable;
        StringVector m_argv;
        std::string m_cwd;
        std::optional<StringVector> m_env;
        std::optional<SchedulerSettingsVariant> m_sched_settings;
 
        FileDescriptor m_stdout;
        FileDescriptor m_stderr;
        FileDescriptor m_stdin;
        std::vector<FileDescriptor> m_inherit_fds;
 
        Callback m_post_fork_cb = nullptr;
 
        friend std::ostream& operator<<(std::ostream&, const ChildCloner&);
};
 
} // end ns
 
 
inline cosmos::ChildCloner& operator<<(cosmos::ChildCloner &cloner, const std::string_view arg) {
        if (!cloner.hasExe()) {
                cloner.setExe(arg);
        } else {
                cloner.getArgs().push_back(std::string{arg});
        }
 
        return cloner;
}
 
COSMOS_API std::ostream& operator<<(std::ostream&, const cosmos::ChildCloner &);