WatchdogService.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <stop_token>
#include <thread>
 
#include "corium/BackgroundService.hpp"
#include "corium/safety/WatchdogSupervisor.hpp"
#include "corium/timers/ClockPolicies.hpp"
 
namespace corium::safety {
 
template <
    typename EventVariant = DefaultEvents,
    std::size_t MaxServices = 16,
    typename ClockPolicy = ChronoClockPolicy
>
class WatchdogService : public BackgroundService<EventVariant> {
public:
    using SupervisorType = WatchdogSupervisor<MaxServices, ClockPolicy>;
    using KickCallbackFn = typename SupervisorType::KickCallbackFn;
 
    explicit WatchdogService(std::chrono::milliseconds checkInterval = std::chrono::milliseconds(20))
        : _checkInterval(checkInterval)
    {}
 
    void setWatchdogKickCallback(KickCallbackFn kickFn, void* userData = nullptr) noexcept
    {
        _supervisor.setWatchdogKickCallback(kickFn, userData);
    }
 
    bool registerService(uint32_t serviceId, uint64_t timeoutNs) noexcept
    {
        return _supervisor.registerService(serviceId, timeoutNs);
    }
 
    void beat(uint32_t serviceId) noexcept
    {
        _supervisor.beat(serviceId);
    }
 
    [[nodiscard]] SupervisorType& supervisor() noexcept
    {
        return _supervisor;
    }
 
    [[nodiscard]] const SupervisorType& supervisor() const noexcept
    {
        return _supervisor;
    }
 
    void run(const std::stop_token& stopToken)
    {
        while (!stopToken.stop_requested()) {
            std::this_thread::sleep_for(_checkInterval);
            _supervisor.supervise(this->context().mainSink());
        }
    }
 
private:
    std::chrono::milliseconds _checkInterval;
    SupervisorType _supervisor;
};
 
} // namespace corium::safety