Add Unix/POSIX signal handling support

Author: Geenz

src/Core/EntropyApplication.cpp

@@ -17,6 +17,11 @@
 #if defined(_WIN32)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
+#else
+#include <signal.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
 #endif
 
 namespace EntropyEngine { namespace Core {
@@ -66,6 +71,18 @@ int EntropyApplication::run() {
     if (_cfg.installSignalHandlers) {
         installSignalHandlers();
     }
+#else
+    // Create signal notification pipe for Unix
+    if (_signalPipe[0] == -1) {
+        if (pipe(_signalPipe) == 0) {
+            // Set both ends non-blocking
+            fcntl(_signalPipe[0], F_SETFL, O_NONBLOCK);
+            fcntl(_signalPipe[1], F_SETFL, O_NONBLOCK);
+        }
+    }
+    if (_cfg.installSignalHandlers) {
+        installSignalHandlers();
+    }
 #endif
 
     // Drive service lifecycle
@@ -106,8 +123,34 @@ int EntropyApplication::run() {
     }
 #else
     {
-        std::unique_lock<std::mutex> lk(_loopMutex);
-        _loopCv.wait(lk, [&]{ return _terminateRequested.load(std::memory_order_acquire); });
+        // Unix wait loop with signal handling
+        if (_cfg.installSignalHandlers && _signalPipe[0] != -1) {
+            // Use poll() to wait on both condition variable and signal pipe
+            for (;;) {
+                if (_terminateRequested.load(std::memory_order_acquire)) {
+                    break;
+                }
+
+                // Check signal pipe with short timeout
+                struct pollfd pfd;
+                pfd.fd = _signalPipe[0];
+                pfd.events = POLLIN;
+                int ret = poll(&pfd, 1, 100); // 100ms timeout
+
+                if (ret > 0 && (pfd.revents & POLLIN)) {
+                    // Signal received - drain pipe and handle
+                    char buf[1];
+                    while (read(_signalPipe[0], buf, 1) > 0);
+
+                    int signum = _lastSignal.load(std::memory_order_relaxed);
+                    handlePosixSignal(signum);
+                }
+            }
+        } else {
+            // Fallback to condition_variable if signal handlers not installed
+            std::unique_lock<std::mutex> lk(_loopMutex);
+            _loopCv.wait(lk, [&]{ return _terminateRequested.load(std::memory_order_acquire); });
+        }
     }
 #endif
 
@@ -123,6 +166,18 @@ int EntropyApplication::run() {
         CloseHandle(static_cast<HANDLE>(_terminateEvent));
         _terminateEvent = nullptr;
     }
+#else
+    if (_cfg.installSignalHandlers) {
+        uninstallSignalHandlers();
+    }
+    if (_signalPipe[0] != -1) {
+        close(_signalPipe[0]);
+        _signalPipe[0] = -1;
+    }
+    if (_signalPipe[1] != -1) {
+        close(_signalPipe[1]);
+        _signalPipe[1] = -1;
+    }
 #endif
 
     _running.store(false);
@@ -232,6 +287,131 @@ void EntropyApplication::handleConsoleSignal(unsigned long ctrlType) {
         }
     }
 }
+#else
+// Unix/POSIX signal handling
+namespace {
+    // Signal handler - must be async-signal-safe
+    static void EntropySigHandler(int signum) {
+        EntropyEngine::Core::EntropyApplication::shared().notifyPosixSignalFromHandler(signum);
+    }
+}
+
+void EntropyApplication::installSignalHandlers() {
+    if (_handlersInstalled.exchange(true)) return;
+
+    // Set up sigaction for graceful termination signals
+    struct sigaction sa;
+    sa.sa_handler = EntropySigHandler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+
+    // Install handlers for common signals
+    sigaction(SIGINT, &sa, nullptr);   // Ctrl+C
+    sigaction(SIGTERM, &sa, nullptr);  // termination request
+    sigaction(SIGHUP, &sa, nullptr);   // hangup
+    sigaction(SIGQUIT, &sa, nullptr);  // quit signal
+
+    // For fatal signals like SIGSEGV, SIGABRT - also install but allow default behavior after logging
+    struct sigaction fatal_sa;
+    fatal_sa.sa_handler = EntropySigHandler;
+    sigemptyset(&fatal_sa.sa_mask);
+    fatal_sa.sa_flags = SA_RESETHAND; // Reset to default after first signal
+
+    sigaction(SIGABRT, &fatal_sa, nullptr);  // abort
+    sigaction(SIGSEGV, &fatal_sa, nullptr);  // segmentation fault
+    sigaction(SIGBUS, &fatal_sa, nullptr);   // bus error
+    sigaction(SIGFPE, &fatal_sa, nullptr);   // floating point exception
+    sigaction(SIGILL, &fatal_sa, nullptr);   // illegal instruction
+}
+
+void EntropyApplication::uninstallSignalHandlers() {
+    if (!_handlersInstalled.exchange(false)) return;
+
+    // Restore default signal handlers
+    signal(SIGINT, SIG_DFL);
+    signal(SIGTERM, SIG_DFL);
+    signal(SIGHUP, SIG_DFL);
+    signal(SIGQUIT, SIG_DFL);
+    signal(SIGABRT, SIG_DFL);
+    signal(SIGSEGV, SIG_DFL);
+    signal(SIGBUS, SIG_DFL);
+    signal(SIGFPE, SIG_DFL);
+    signal(SIGILL, SIG_DFL);
+}
+
+void EntropyApplication::notifyPosixSignalFromHandler(int signum) noexcept {
+    _lastSignal.store(signum, std::memory_order_relaxed);
+    // Write to pipe to wake up main thread (signal-safe operation)
+    if (_signalPipe[1] != -1) {
+        char byte = 1;
+        (void)write(_signalPipe[1], &byte, 1);
+    }
+}
+
+void EntropyApplication::handlePosixSignal(int signum) {
+    // Map signals we care about
+    bool isFatal = false;
+    switch (signum) {
+        case SIGINT:
+        case SIGTERM:
+        case SIGHUP:
+        case SIGQUIT:
+            break; // Graceful termination signals
+        case SIGABRT:
+        case SIGSEGV:
+        case SIGBUS:
+        case SIGFPE:
+        case SIGILL:
+            isFatal = true;
+            break;
+        default:
+            return; // ignore others
+    }
+
+    bool first = !_signalSeen.exchange(true);
+
+    if (first) {
+        // Optionally consult delegate; if vetoed, just return on first request
+        bool allow = true;
+        if (_delegate && !isFatal) {
+            try { allow = _delegate->applicationShouldTerminate(); }
+            catch (...) { /* swallow in signal path */ }
+        }
+
+        if (allow || isFatal) {
+            terminate(isFatal ? 1 : 0);
+        }
+
+        // Start escalation timer after first signal regardless, to avoid hanging forever
+        if (!_escalationStarted.exchange(true) && !isFatal) {
+            auto deadline = _cfg.shutdownDeadline;
+            std::weak_ptr<EntropyApplication> weak = EntropyApplication::sharedPtr();
+            std::thread([weak, deadline]{
+                auto endAt = std::chrono::steady_clock::now() + deadline;
+                std::this_thread::sleep_until(endAt);
+                if (auto sp = weak.lock()) {
+                    if (sp->isRunning()) {
+                        // Escalate: attempt a harder exit
+                        sp->terminate(1);
+                        std::this_thread::sleep_for(std::chrono::milliseconds(200));
+                        if (sp->isRunning()) {
+                            std::quick_exit(1);
+                        }
+                    }
+                }
+            }).detach();
+        }
+    } else {
+        // Subsequent signal: escalate immediately
+        if (_running.load()) {
+            terminate(1);
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            if (_running.load()) {
+                std::quick_exit(1);
+            }
+        }
+    }
+}
 #endif
 
 

src/Core/EntropyApplication.h

@@ -65,6 +65,11 @@ class EntropyApplication {
     void handleConsoleSignal(unsigned long ctrlType);
     // Signal-safe notification from console handler (sets flag and signals event)
     void notifyConsoleSignalFromHandler(unsigned long ctrlType) noexcept;
+#else
+    // Exposed for Unix signal handler forwarder
+    void handlePosixSignal(int signum);
+    // Signal-safe notification from signal handler
+    void notifyPosixSignalFromHandler(int signum) noexcept;
 #endif
 
 private:
@@ -75,6 +80,10 @@ class EntropyApplication {
     // Windows console control handling
     void installSignalHandlers();
     void uninstallSignalHandlers();
+#else
+    // Unix/POSIX signal handling
+    void installSignalHandlers();
+    void uninstallSignalHandlers();
 #endif
 
     // Fields
@@ -95,6 +104,13 @@ class EntropyApplication {
     void* _ctrlEvent{nullptr};      // HANDLE, kept as void* to avoid windows.h in header (auto-reset)
     void* _terminateEvent{nullptr}; // HANDLE, kept as void* (manual-reset)
     std::atomic<unsigned long> _lastCtrlType{0};
+#else
+    std::atomic<bool> _handlersInstalled{false};
+    std::atomic<bool> _signalSeen{false};
+    std::atomic<bool> _escalationStarted{false};
+    // Unix signal handling internals
+    int _signalPipe[2]{-1, -1};     // Pipe for signal-safe notification
+    std::atomic<int> _lastSignal{0};
 #endif
 
     // Inline wait primitives (replacing EntropyRunLoop)