process.hpp

#pragma once


#include <algorithm>
#include <utility>
#include <memory>
#include <string>
#include <vector>
#include <uv.h>
#include "handle.hpp"
#include "stream.hpp"
#include "util.hpp"
#include "loop.hpp"


namespace uvw {


namespace details {


enum class UVProcessFlags: std::underlying_type_t<uv_process_flags> {
    SETUID = UV_PROCESS_SETUID,
    SETGID = UV_PROCESS_SETGID,
    WINDOWS_VERBATIM_ARGUMENTS = UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
    DETACHED = UV_PROCESS_DETACHED,
    WINDOWS_HIDE = UV_PROCESS_WINDOWS_HIDE
};


enum class UVStdIOFlags: std::underlying_type_t<uv_stdio_flags> {
    IGNORE_STREAM = UV_IGNORE,
    CREATE_PIPE = UV_CREATE_PIPE,
    INHERIT_FD = UV_INHERIT_FD,
    INHERIT_STREAM = UV_INHERIT_STREAM,
    READABLE_PIPE = UV_READABLE_PIPE,
    WRITABLE_PIPE = UV_WRITABLE_PIPE,
    OVERLAPPED_PIPE = UV_OVERLAPPED_PIPE
};


}


struct ExitEvent {
    explicit ExitEvent(int64_t code, int sig) noexcept
        : status{code}, signal{sig}
    {}

    int64_t status; 
    int signal; 
};

class ProcessHandle final: public Handle<ProcessHandle, uv_process_t> {
    static void exitCallback(uv_process_t *handle, int64_t exitStatus, int termSignal) {
        ProcessHandle &process = *(static_cast<ProcessHandle*>(handle->data));
        process.publish(ExitEvent{exitStatus, termSignal});
    }

public:
    using Process = details::UVProcessFlags;
    using StdIO = details::UVStdIOFlags;

    ProcessHandle(ConstructorAccess ca, std::shared_ptr<Loop> ref)
        : Handle{ca, std::move(ref)}, poFdStdio{1}
    {
        // stdin container default initialization
        poFdStdio[0].flags = static_cast<uv_stdio_flags>(StdIO::IGNORE_STREAM);
    }

    static void disableStdIOInheritance() noexcept {
        uv_disable_stdio_inheritance();
    }

    static bool kill(int pid, int signum) noexcept {
        return (0 == uv_kill(pid, signum));
    }

    bool init() {
        // deferred initialization: libuv initializes process handles only when
        // uv_spawn is invoked and uvw stays true to the underlying library
        return true;
    }

    void spawn(const char *file, char **args, char **env = nullptr) {
        uv_process_options_t po;

        po.exit_cb = &exitCallback;

        po.file = file;
        po.args = args;
        po.env = env;
        po.cwd = poCwd.empty() ? nullptr : poCwd.data();
        po.flags = poFlags;
        po.uid = poUid;
        po.gid = poGid;

        std::vector<uv_stdio_container_t> poStdio;
        poStdio.reserve(poFdStdio.size() + poStreamStdio.size());
        poStdio.insert(poStdio.begin(), poFdStdio.cbegin(), poFdStdio.cend());
        poStdio.insert(poStdio.end(), poStreamStdio.cbegin(), poStreamStdio.cend());
       
        po.stdio_count = static_cast<decltype(po.stdio_count)>(poStdio.size());
        po.stdio = poStdio.data();

        // fake initialization so as to have leak invoked
        // see init member function for more details
        initialize([](auto...){ return 0; });

        invoke(&uv_spawn, parent(), get(), &po);
    }

    void kill(int signum) {
        invoke(&uv_process_kill, get(), signum);
    }

    int pid() noexcept {
        return get()->pid;
    }

    ProcessHandle & cwd(std::string path) noexcept {
        poCwd = path;
        return *this;
    }

    ProcessHandle & flags(Flags<Process> flags) noexcept {
        poFlags = flags;
        return *this;
    }

    template<typename T, typename U>
    ProcessHandle & stdio(StreamHandle<T, U> &stream, Flags<StdIO> flags) {
        uv_stdio_container_t container;
        Flags<StdIO>::Type fgs = flags;
        container.flags = static_cast<uv_stdio_flags>(fgs);
        container.data.stream = get<uv_stream_t>(stream);
        poStreamStdio.push_back(std::move(container));
        return *this;
    }

    ProcessHandle & stdio(FileHandle fd, Flags<StdIO> flags) {
        auto fgs = static_cast<uv_stdio_flags>(Flags<StdIO>::Type{flags});

        auto actual = FileHandle::Type{fd};

        if(actual == FileHandle::Type{StdIN}) {
            poFdStdio[0].flags = fgs;
        } else {
            auto it = std::find_if(poFdStdio.begin(), poFdStdio.end(), [actual](auto &&container){
                return container.data.fd == actual;
            });

            if(it == poFdStdio.cend()) {
                uv_stdio_container_t container;
                container.flags = fgs;
                container.data.fd = actual;
                poFdStdio.push_back(std::move(container));
            } else {
                it->flags = fgs;
                it->data.fd = actual;
            }
        }

        return *this;
    }

    ProcessHandle & uid(Uid id) {
        poUid = id;
        return *this;
    }

    ProcessHandle & gid(Gid id) {
        poGid = id;
        return *this;
    }

private:
    std::string poCwd;
    Flags<Process> poFlags;
    std::vector<uv_stdio_container_t> poFdStdio;
    std::vector<uv_stdio_container_t> poStreamStdio;
    Uid poUid;
    Gid poGid;
};


}