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_COMPILER_MSVC
#    include <consoleapi.h>
#endif
#ifdef NEFORCE_COMPILER_MINGW
#    include <windef.h>
#    include <wincon.h>
#endif
#ifdef NEFORCE_PLATFORM_LINUX
#    include <csignal>
#endif
NEFORCE_BEGIN_NAMESPACE__


enum class signal_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
};
 

class NEFORCE_API signal_manager {
public:
    using signal_handler = function<bool(signal_event, void*)>;
 
private:
    struct signal_result {
        signal_event event; 
        void* context;      
    };

    struct pending_signal {
        signal_event event;                 
        void* context;                      
        steady_clock::time_point timestamp; 
 
        pending_signal(const signal_event event, void* context, steady_clock::time_point timestamp) :
        event{event},
        context{context},
        timestamp{timestamp} {}
    };
 
    atomic<bool> running_{false};          
    atomic<bool> force_exit_{false};       
    atomic<int> force_exit_timeout_{5000}; 
 
    mutex mutex_;           
    condition_variable cv_; 
 
    unordered_map<signal_event, signal_handler> handlers_; 
    vector<pending_signal> pending_signals_;               
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    vector<::DWORD> registered_windows_events_; 
#else
    struct ::sigaction old_actions_[64]{}; 
    ::timer_t alarm_timer_{nullptr};       
#endif
 
    thread signal_thread_;  
    thread timeout_thread_; 
 
private:
    void initialize_platform();
    void cleanup_platform() const;
 
    void signal_thread_func();
    void timeout_monitor_thread();
 
    void process_signal(signal_event event, void* context = nullptr);
 
    signal_result wait_for_signal_internal(int timeout_ms = -1);
    void send_signal_nolock(signal_event event, void* context = nullptr);
 
    signal_manager();
 
public:
    signal_manager(const signal_manager&) = delete;
    signal_manager& operator=(const signal_manager&) = delete;
    signal_manager(const signal_manager&&) = delete;
    signal_manager& operator=(const signal_manager&&) = delete;

    ~signal_manager();

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

    void register_handler(signal_event event, signal_handler handler);

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

    void remove_handler(signal_event event);

    signal_event wait_for_signal(int timeout_ms = -1);

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

    void set_force_exit_timeout(int timeout_ms);

    void start_monitoring();

    void stop_monitoring();

    NEFORCE_NODISCARD bool is_running() const;

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

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

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

class signal_guard {
public:
    signal_guard() { signal_manager::instance().start_monitoring(); }

    ~signal_guard() { signal_manager::instance().stop_monitoring(); }
};
 // SystemSignal
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_SIGNAL_HPP__