FallbackRecoveryTimer.hpp

#pragma once
 
#include "util/Mutex.hpp"
 
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/asio/thread_pool.hpp>
#include <boost/system/error_code.hpp>
 
#include <chrono>
#include <memory>
 
namespace cluster::impl {

class FallbackRecoveryTimer {
    struct Impl {
        boost::asio::steady_timer timer;
        bool isRunning = false;
        std::chrono::steady_clock::duration recoveryTime;
 
        Impl(
            boost::asio::any_io_executor const& executor,
            std::chrono::steady_clock::duration recoveryTime
        )
            : timer(executor), recoveryTime(recoveryTime)
        {
        }
    };
 
    std::shared_ptr<util::Mutex<Impl>> impl_;
 
public:
    FallbackRecoveryTimer(
        boost::asio::thread_pool& ctx,
        std::chrono::steady_clock::duration recoveryTime
    );

    [[nodiscard]] bool
    isRunning() const;

    template <typename Callback>
    void
    start(Callback&& callback)
    {
        auto locked = impl_->lock();
        locked->isRunning = true;
        locked->timer.expires_after(locked->recoveryTime);
        locked->timer.async_wait([impl = impl_, cb = std::forward<Callback>(callback)](
                                     boost::system::error_code ec
                                 ) mutable {
            impl->lock()->isRunning = false;
            cb(ec);
        });
    }

    void
    cancel();
};
 
}  // namespace cluster::impl