signal.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_SYSTEM_SIGNAL_HPP__
#define NEFORCE_CORE_SYSTEM_SIGNAL_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/async/condition_variable.hpp"
#include "NeForce/core/async/thread.hpp"
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/functional/function.hpp"
#ifdef NEFORCE_PLATFORM_WINDOWS
#    include "NeForce/core/system/system_event.hpp"
#    include <consoleapi.h>
#    ifdef NEFORCE_COMPILER_MINGW
#        include <windef.h>
#        include <wingdi.h>
#        include <wincon.h>
#    endif
#endif
#ifdef NEFORCE_PLATFORM_LINUX
#    include <csignal>
#endif
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API system_signal_manager {
public:
    enum class event {
#ifdef NEFORCE_PLATFORM_WINDOWS
        INTERRUPT = CTRL_C_EVENT,       
        CTRL_BREAK = CTRL_BREAK_EVENT,  
        CLOSE = CTRL_CLOSE_EVENT,       
        LOGOFF = CTRL_LOGOFF_EVENT,     
        SHUTDOWN = CTRL_SHUTDOWN_EVENT, 
 
        TERMINATE = 1000,      
        ABORT = 1001,          
        ILLEGAL_INSTR = 1002,  
        FLOATING_POINT = 1003, 
        SEGMENT_FAULT = 1004,  
        BUS_ERROR = 1005,      
        PIPE_BROKEN = 1006,    
        ALARM = 1007,          
        HANGUP = 1008,         
        USER1 = 1009,          
        USER2 = 1010,          
 
        TIMEOUT = 2000,   
        CUSTOM_1 = 2001,  
        CUSTOM_2 = 2002,  
        FORCE_EXIT = 9999 
#else
        INTERRUPT = SIGINT,      
        TERMINATE = SIGTERM,     
        ABORT = SIGABRT,         
        ILLEGAL_INSTR = SIGILL,  
        FLOATING_POINT = SIGFPE, 
        SEGMENT_FAULT = SIGSEGV, 
        BUS_ERROR = SIGBUS,      
        PIPE_BROKEN = SIGPIPE,   
        ALARM = SIGALRM,         
        HANGUP = SIGHUP,         
        USER1 = SIGUSR1,         
        USER2 = SIGUSR2,         
 
        CTRL_BREAK = 1000, 
        CLOSE = 1001,      
        LOGOFF = 1002,     
        SHUTDOWN = 1003,   
 
        TIMEOUT = 2000,   
        CUSTOM_1 = 2001,  
        CUSTOM_2 = 2002,  
        FORCE_EXIT = 9999 
#endif
    };

    using signal_handler = function<bool(event, void*)>;
 
private:
    struct signal_result {
        system_signal_manager::event event; 
        void* context;                      
    };

    struct pending_signal {
        event signal_event;                 
        void* context;                      
        steady_clock::time_point timestamp; 
 
        pending_signal(const event event, void* context, const steady_clock::time_point timestamp) :
        signal_event{event},
        context{context},
        timestamp{timestamp} {}
    };
 
    atomic<bool> running_{false};          
    atomic<bool> force_exit_{false};       
    atomic<int> force_exit_timeout_{5000}; 
 
    atomic<int> guard_count_{0}; // 作用域管理器的引用计数
 
    mutex mutex_;           
    condition_variable cv_; 
 
    unordered_map<event, signal_handler> handlers_; 
    vector<pending_signal> pending_signals_;        
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    system_event notify_event_; 
#else
    struct ::sigaction old_actions_[64]{}; 
#endif
 
    thread signal_thread_;  
    thread timeout_thread_; 
 
    friend class signal_guard;
 
    system_signal_manager();
 
    void add_guard_ref() {
        if (guard_count_++ == 0) {
            start_monitoring();
        }
    }
 
    void remove_guard_ref() noexcept {
        if (--guard_count_ == 0) {
            stop_monitoring();
        }
    }
 
    void initialize();
    void cleanup();
 
    void signal_thread_func();
    void timeout_monitor_thread();
 
    void process_signal(event event, void* context);
    void trigger_force_exit();
    signal_result wait_for_signal_internal(int timeout_ms = -1);
    void send_signal_nolock(event event, void* context);
 
public:
    system_signal_manager(const system_signal_manager&) = delete;
    system_signal_manager& operator=(const system_signal_manager&) = delete;
    system_signal_manager(const system_signal_manager&&) = delete;
    system_signal_manager& operator=(const system_signal_manager&&) = delete;
 
    ~system_signal_manager();

    static system_signal_manager& instance() {
        static system_signal_manager instance;
        return instance;
    }

    void register_handler(event event, signal_handler handler);

    void register_handlers(const vector<event>& events, const signal_handler& handler);

    void remove_handler(event event);

    event wait_for_signal(int timeout_ms = -1);

    void send_signal(event event, void* context = nullptr);

    void set_force_exit_timeout(int timeout_ms);

    void start_monitoring();

    void stop_monitoring() noexcept;

    void reset_force();

    NEFORCE_NODISCARD bool is_running() const;

    bool block_signals(const vector<event>& signals_to_block) const;

    bool unblock_signals(const vector<event>& signals_to_unblock) const;

    NEFORCE_NODISCARD static bool is_platform_signal(event event) {
#ifdef NEFORCE_PLATFORM_WINDOWS
        return static_cast<::DWORD>(event) <= CTRL_SHUTDOWN_EVENT;
#else
        int v = static_cast<int>(event);
        return v > 0 && v < 64;
#endif
    }
};

class signal_guard {
public:
    signal_guard() { system_signal_manager::instance().add_guard_ref(); }

    ~signal_guard() { system_signal_manager::instance().remove_guard_ref(); }
 
    signal_guard(const signal_guard&) = delete;
    signal_guard& operator=(const signal_guard&) = delete;
    signal_guard(signal_guard&&) = delete;
    signal_guard& operator=(signal_guard&&) = delete;
};
 // SystemSignal
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_SIGNAL_HPP__