child.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdlib>
#include <cstring>
#include <sys/wait.h>
#include <csignal>
#include <string>
#include <optional>
#include <utility>
#include <memory>
#include <thread>
#include <vector>
 
#include "../../macro.hpp"
#include "../../std/expected.hpp"
 
namespace ns_subprocess
{
 
// Forward declaration
class Subprocess;

class Child
{
  private:
    pid_t m_pid;
    std::string m_description;
    std::vector<std::jthread> m_pipe_threads;
 
    friend class Subprocess;

    Child(pid_t pid, std::string description, std::vector<std::jthread> threads)
      : m_pid(pid)
      , m_description(std::move(description))
      , m_pipe_threads(std::move(threads))
    {}

    static std::unique_ptr<Child> create(pid_t pid, std::string const& description, std::vector<std::jthread> threads = {})
    {
      return std::unique_ptr<Child>(new Child(pid, description, std::move(threads)));
    }
 
  public:
    ~Child()
    {
      if (m_pid > 0)
      {
        std::ignore = wait();
      }
    }
 
    // Delete copy and move operations - Child is non-copyable and non-moveable
    Child(Child const&) = delete;
    Child& operator=(Child const&) = delete;
    Child(Child&&) = delete;
    Child& operator=(Child&&) = delete;

    [[nodiscard]] Value<int> wait()
    {
      // Check if pid is valid
      return_if(m_pid <= 0, Error("E::Invalid pid to wait for in {}", m_description));
 
      // Wait for current process
      int status;
      pid_t result = waitpid(m_pid, &status, 0);
      if (result < 0)
      {
        if (errno == ECHILD)
        {
          return Error("D::Skipping wait on daemon process {}", m_pid);
        }
        return Error("E::waitpid failed on {}: {}", m_description, strerror(errno));
      }
 
      // Clear jthreads, auto-join
      m_pipe_threads.clear();
 
      // Mark pid as invalid to prevent double-wait
      m_pid = -1;
 
      return WIFEXITED(status)? Value<int>(WEXITSTATUS(status))
        : WIFSIGNALED(status)? Error("E::The process {} was terminated by a signal", m_description)
        : WIFSTOPPED(status)? Error("E::The process {} was stopped by a signal", m_description)
        : Error("E::The process {} exited abnormally", m_description);
    }

    [[nodiscard]] std::optional<pid_t> get_pid() const
    {
      return (m_pid > 0) ? std::optional<pid_t>(m_pid) : std::nullopt;
    }

    void kill(int signal)
    {
      if (m_pid > 0)
      {
        ::kill(m_pid, signal);
      }
    }
};
 
} // namespace ns_subprocess