child_process.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
 
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::platform {

struct ProcessResult {
    int exit_code = -1;
    std::string stdout_output;
    std::string stderr_output;
    bool timed_out = false;
    bool was_cancelled = false;
    bool output_limit_exceeded = false;
};

struct ProcessOptions {
    std::string working_directory;
    int working_directory_descriptor = -1;
    std::function<bool(int process_id)> suspended_process_validator;
    int timeout_ms = 0;                    
    size_t max_output_bytes = 1 << 20;     
    bool capture_stdout = true;
    bool capture_stderr = true;
    std::function<void(std::string_view line)> on_stdout_line;
    std::function<void(std::string_view line)> on_stderr_line;
    int standard_input_timeout_ms = 3000;  
    size_t max_standard_input_provider_bytes = 1 << 20;  
};

using StandardInputByteProvider =
    std::function<std::optional<std::vector<std::uint8_t>>(int child_process_id)>;

class ChildProcessInputChannel {
public:
    ~ChildProcessInputChannel();
    ChildProcessInputChannel(const ChildProcessInputChannel&) = delete;
    ChildProcessInputChannel& operator=(const ChildProcessInputChannel&) = delete;
    ChildProcessInputChannel(ChildProcessInputChannel&& other) noexcept;
    ChildProcessInputChannel& operator=(ChildProcessInputChannel&& other) noexcept;
 
    std::intptr_t native_handle() const noexcept { return handle_; }
    explicit operator bool() const noexcept { return handle_ >= 0; }
 
private:
    friend class ChildProcess;
    explicit ChildProcessInputChannel(std::intptr_t handle) noexcept : handle_(handle) {}
    std::intptr_t handle_ = -1;
};

using StandardInputChannelSession =
    std::function<bool(int child_process_id, ChildProcessInputChannel channel,
                       std::chrono::steady_clock::time_point deadline)>;

class ChildProcess {
public:
    ChildProcess();
    ~ChildProcess();
    ChildProcess(ChildProcess&&) noexcept;
    ChildProcess& operator=(ChildProcess&&) noexcept;
 
    ChildProcess(const ChildProcess&) = delete;
    ChildProcess& operator=(const ChildProcess&) = delete;

    static ProcessResult run(const std::string& command,
                             const std::vector<std::string>& args,
                             const ProcessOptions& options = {});

    bool start(const std::string& command,
               const std::vector<std::string>& args,
               const ProcessOptions& options = {});

    bool start_with_standard_input(const std::string& command, const std::vector<std::string>& args,
                                   std::span<const std::uint8_t> bytes,
                                   const ProcessOptions& options = {});

    bool start_with_standard_input(const std::string& command, const std::vector<std::string>& args,
                                   const StandardInputByteProvider& provider,
                                   const ProcessOptions& options = {});

    bool start_with_standard_input_channel(const std::string& command,
                                           const std::vector<std::string>& args,
                                           const StandardInputChannelSession& session,
                                           const ProcessOptions& options = {});

    bool is_running() const;

    int process_id() const;

    void cancel();

    ProcessResult wait();

    std::string read_available_output();
 
private:
    bool start_impl(const std::string& command, const std::vector<std::string>& args,
                    const ProcessOptions& options,
                    const std::span<const std::uint8_t>* standard_input,
                    const StandardInputByteProvider* standard_input_provider,
                    const StandardInputChannelSession* standard_input_session);
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

ProcessResult exec(const std::string& command,
                   const std::vector<std::string>& args = {},
                   int timeout_ms = 30000);

std::optional<std::filesystem::path> find_on_path(const std::string& binary_name);
 
}  // namespace pulp::platform