child_process_manager.hpp

Go to the documentation of this file.

#pragma once
 
// ConnectedChildProcess — launch a child process with an IPC channel.
// ChildProcessManager — manage a pool of child processes (for plugin scanning etc.)
 
#include <pulp/events/interprocess_connection.hpp>
#include <pulp/platform/child_process.hpp>
#include <string>
#include <string_view>
#include <vector>
#include <memory>
#include <functional>
#include <atomic>
#include <thread>
#include <mutex>
#include <condition_variable>
 
namespace pulp::events {

class ConnectedChildProcess {
public:
    ConnectedChildProcess() = default;
    ~ConnectedChildProcess();

    bool launch(std::string_view executable,
                const std::vector<std::string>& extra_args = {});

    bool is_running() const { return running_.load(); }

    int pid() const { return pid_.load(); }

    bool send_message(std::string_view message);

    void kill();

    int wait_for_exit(int timeout_ms = 0);

    std::function<void(std::string_view)> on_message;

    std::function<void(int exit_code)> on_exit;

    InterprocessConnection& connection() { return connection_; }
 
    // No copy
    ConnectedChildProcess(const ConnectedChildProcess&) = delete;
    ConnectedChildProcess& operator=(const ConnectedChildProcess&) = delete;
 
private:
    bool join_monitor_thread(bool detach_current_thread);
    bool begin_message_callback();
    void end_message_callback();
    void stop_accepting_message_callbacks();
    void wait_for_message_callbacks();
 
    InterprocessConnection connection_;
    pulp::platform::ChildProcess process_;
    std::string pipe_name_;
    std::atomic<int> pid_{-1};
    std::atomic<bool> running_{false};
    bool cancel_requested_ = false;
    bool exit_ready_ = false;
    int exit_code_ = -1;
    std::mutex state_mutex_;
    std::condition_variable exit_cv_;
    std::mutex monitor_mutex_;
    std::condition_variable monitor_cv_;
    bool monitor_launch_pending_ = false;
    bool monitor_join_in_progress_ = false;
    std::thread::id monitor_thread_id_;
    std::thread monitor_thread_;
    std::mutex message_callback_mutex_;
    std::condition_variable message_callback_cv_;
    int active_message_callbacks_ = 0;
    // Closed only by the destructor; normal kill/relaunch keeps callbacks armed.
    bool accepting_message_callbacks_ = true;
};

class ChildProcessManager {
public:
    ChildProcessManager() = default;
    ~ChildProcessManager();

    ConnectedChildProcess* launch(std::string_view executable,
                                   const std::vector<std::string>& args = {});

    int active_count() const;

    void kill_all();

    void wait_all(int timeout_ms = 0);

    void cleanup();

    std::function<void(ConnectedChildProcess*, int exit_code)> on_child_exit;
 
    // No copy
    ChildProcessManager(const ChildProcessManager&) = delete;
    ChildProcessManager& operator=(const ChildProcessManager&) = delete;
 
private:
    std::vector<std::shared_ptr<ConnectedChildProcess>> children_;
    mutable std::mutex mutex_;
};
 
}  // namespace pulp::events