signal_stop.hpp

#pragma once
 
#include "./stop.hpp"
 
#include <atomic>
#include <csignal>
 
namespace algotradelib {
namespace runner {

class SignalStop {
public:
  static void install(StopSource& source) noexcept {
    slot().store(&source, std::memory_order_release);
    std::signal(SIGINT, &SignalStop::handle);
    std::signal(SIGTERM, &SignalStop::handle);
#ifdef SIGHUP
    // Ignored: SIGHUP's default disposition would terminate the process.
    std::signal(SIGHUP, SIG_IGN);
#endif
  }

  static void uninstall() noexcept {
    std::signal(SIGINT, SIG_DFL);
    std::signal(SIGTERM, SIG_DFL);
#ifdef SIGHUP
    std::signal(SIGHUP, SIG_DFL);
#endif
    slot().store(nullptr, std::memory_order_release);
  }

  static StopSource* installed() noexcept { return slot().load(std::memory_order_acquire); }
 
private:
  // The handler, which does exactly one thing.
  //
  // Everything async-signal-unsafe is absent by construction: no allocation, no locking, no I/O, no
  // `errno` use. It loads a pointer from a lock-free atomic and calls `StopSource::request`, which
  // is itself nothing but a compare-exchange on a lock-free atomic.
  static void handle(int) noexcept {
    if (StopSource* source = slot().load(std::memory_order_acquire)) {
      source->request(StopIntent::QUIESCE);
    }
  }
 
  // Where the handler finds its destination.
  //
  // Atomic because a handler can run on any thread at any time relative to `install`, and a
  // plain pointer read would be a data race. Function-local static inside an inline accessor keeps
  // this header-only with exactly one instance across translation units.
  static std::atomic<StopSource*>& slot() noexcept {
    static std::atomic<StopSource*> value{nullptr};
    return value;
  }
};
 
} // namespace runner
} // namespace algotradelib