SignalsHandler.hpp

#pragma once
 
#include "util/config/ConfigDefinition.hpp"
#include "util/log/Logger.hpp"
 
#include <boost/signals2/signal.hpp>
 
#include <atomic>
#include <chrono>
#include <concepts>
#include <condition_variable>
#include <csignal>
#include <cstdlib>
#include <functional>
#include <mutex>
#include <thread>
 
namespace util {
namespace impl {
 
class SignalsHandlerStatic;
 
}  // namespace impl

class SignalsHandler {
    enum class State { WaitingForSignal, GracefulShutdown, ForceExit, NormalExit };
 
    std::chrono::steady_clock::duration gracefulPeriod_;
    std::function<void()> forceExitHandler_;
 
    boost::signals2::signal<void()> stopSignal_;
 
    std::atomic<bool> signalReceived_{false};
    std::atomic<State> state_{State::WaitingForSignal};
 
    std::mutex mutex_;
    std::condition_variable cv_;
    std::thread workerThread_;
 
    friend class impl::SignalsHandlerStatic;
 
public:
    enum class Priority { StopFirst = 0, Normal = 1, StopLast = 2 };

    SignalsHandler(
        util::config::ClioConfigDefinition const& config,
        std::function<void()> forceExitHandler = kDEFAULT_FORCE_EXIT_HANDLER
    );
 
    SignalsHandler(SignalsHandler const&) = delete;
    SignalsHandler(SignalsHandler&&) = delete;
    SignalsHandler&
    operator=(SignalsHandler const&) = delete;
    SignalsHandler&
    operator=(SignalsHandler&&) = delete;

    ~SignalsHandler();

    template <std::invocable SomeCallback>
    void
    subscribeToStop(SomeCallback&& callback, Priority priority = Priority::Normal)
    {
        stopSignal_.connect(static_cast<int>(priority), std::forward<SomeCallback>(callback));
    }

    void
    notifyGracefulShutdownComplete();
 
    static constexpr auto kHANDLED_SIGNALS = {SIGINT, SIGTERM};
 
private:
    static void
    setHandler(void (*handler)(int) = nullptr);

    void
    runStateMachine();
 
    static constexpr auto kDEFAULT_FORCE_EXIT_HANDLER = []() { std::exit(EXIT_FAILURE); };
};
 
}  // namespace util