daemon.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_SYSTEM_DAEMON_HPP__
#define NEFORCE_CORE_SYSTEM_DAEMON_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/async/thread.hpp"
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
#include "NeForce/core/system/process.hpp"
#include "NeForce/core/system/signal.hpp"
#include "NeForce/core/system/system_event.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct daemon_exception final : system_exception {
    explicit daemon_exception(const char* info = "Daemon Operation Failed.",
                              const error_code code = last_error()) noexcept :
    system_exception(info, code) {}
 
    explicit daemon_exception(const exception& e) :
    system_exception(e) {}
 
    ~daemon_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "daemon_exception"; }
};
 // Exceptions


class NEFORCE_API daemon {
public:
    enum class daemon_state {
        stopped,   
        starting,  
        running,   
        reloading, 
        stopping   
    };

    struct child_config {
        string name;                       
        string executable;                 
        vector<string> args;               
        string work_dir;                   
        int max_restarts{5};               
        int restart_delay_ms{1000};        
        int health_check_interval_ms{0};   
        int graceful_timeout_ms{5000};     
        bool capture_output{false};        
        vector<pair<string, string>> envs; 
    };

    struct child_status {
        string name;                    
        process::native_id_type pid{0}; 
        int exit_code{0};               
        int restart_count{0};           
        bool running{false};            
    };

    using start_callback = function<void()>;

    using stop_callback = function<void()>;

    using reload_callback = function<bool()>;

    using child_exit_callback = function<void(const string& name, int exit_code)>;
 
private:
    atomic<daemon_state> state_{daemon_state::stopped};
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    void* pid_handle_{nullptr};
#else
    int pid_fd_{-1};
#endif
    string pid_path_;
    string work_dir_{"/"};
 
    unique_ptr<signal_guard> signal_guard_;
 
    system_event shutdown_event_{false, system_event::type::manual_reset};
    system_event reload_event_{false, system_event::type::auto_reset};
 
    struct child_entry {
        child_config config;
        unique_ptr<process> proc;
        int restart_count{0};
        int exit_code{0};
        int64_t last_health_check_ms{0};
        bool running{false};
    };
    mutable mutex children_mutex_;
    unordered_map<string, child_entry> children_;
 
    start_callback on_start_;
    stop_callback on_stop_;
    reload_callback on_reload_;
    child_exit_callback on_child_exit_;
 
    atomic<bool> watchdog_enabled_{false};
    atomic<int> watchdog_timeout_ms_{0};
    atomic<int64_t> last_ping_{0};
    thread watchdog_thread_;
 
    bool daemonize_impl() noexcept;
    void setup_signal_handlers();
    void start_all_children();
    void stop_all_children();
    void check_and_restart_children();
    static void start_child(child_entry& entry);
    void watchdog_loop();
 
public:
    daemon() = default;
    ~daemon();
 
    daemon(const daemon&) = delete;
    daemon& operator=(const daemon&) = delete;
    daemon(daemon&&) = delete;
    daemon& operator=(daemon&&) = delete;

    void on_start(start_callback cb) { on_start_ = move(cb); }

    void on_stop(stop_callback cb) { on_stop_ = move(cb); }

    void on_reload(reload_callback cb) { on_reload_ = move(cb); }

    void on_child_exit(child_exit_callback cb) { on_child_exit_ = move(cb); }

    bool daemonize(const string& work_dir = "/");

    bool write_pid_file(const string& path);

    void remove_pid_file() noexcept;

    NEFORCE_NODISCARD static bool is_pid_file_locked(const string& path) noexcept;

    bool add_child(const child_config& cfg);

    void remove_child(const string& name);

    NEFORCE_NODISCARD child_status get_child_status(const string& name) const;

    NEFORCE_NODISCARD vector<child_status> all_child_statuses() const;

    int run();

    void request_shutdown();

    void request_reload();

    NEFORCE_NODISCARD daemon_state state() const noexcept { return state_.load(); }

    void watchdog_ping();

    void set_watchdog_timeout(int timeout_ms);
 
#ifdef NEFORCE_PLATFORM_LINUX
    static void notify_ready();

    static void notify_status(const string& status);

    static void notify_watchdog();
#endif
};
 // Daemon
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_DAEMON_HPP__