Retry.hpp

#pragma once
 
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/error.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/asio/strand.hpp>
 
#include <atomic>
#include <chrono>
#include <cstddef>
#include <memory>
 
namespace util {

class RetryStrategy {
    std::chrono::steady_clock::duration initialDelay_;
    std::chrono::steady_clock::duration delay_;
 
public:
    RetryStrategy(std::chrono::steady_clock::duration delay);
    virtual ~RetryStrategy() = default;

    [[nodiscard]] std::chrono::steady_clock::duration
    getDelay() const;

    void
    increaseDelay();

    void
    reset();
 
protected:
    [[nodiscard]] virtual std::chrono::steady_clock::duration
    nextDelay() const = 0;
};
using RetryStrategyPtr = std::unique_ptr<RetryStrategy>;

class Retry {
    RetryStrategyPtr strategy_;
    boost::asio::steady_timer timer_;
    size_t attemptNumber_ = 0;
    std::shared_ptr<std::atomic_bool> canceled_{std::make_shared<std::atomic_bool>(false)};
 
public:
    struct Delays {
        std::chrono::steady_clock::duration initial;
        std::chrono::steady_clock::duration max;
    };

    Retry(
        RetryStrategyPtr strategy,
        boost::asio::strand<boost::asio::io_context::executor_type> strand
    );

    Retry(RetryStrategyPtr strategy, boost::asio::any_io_executor executor);

    ~Retry();

    template <typename Fn>
    void
    retry(Fn&& func)
    {
        *canceled_ = false;
        timer_.expires_after(strategy_->getDelay());
        strategy_->increaseDelay();
        timer_.async_wait([this,
                           canceled = canceled_,
                           func = std::forward<Fn>(func)](boost::system::error_code const& ec) {
            if (ec == boost::asio::error::operation_aborted or *canceled) {
                return;
            }
            ++attemptNumber_;
            func();
        });
    }

    void
    wait(boost::asio::yield_context yield);

    void
    cancel();

    [[nodiscard]] size_t
    attemptNumber() const;

    [[nodiscard]] std::chrono::steady_clock::duration
    delayValue() const;

    void
    reset();
};

class ExponentialBackoffStrategy : public RetryStrategy {
    std::chrono::steady_clock::duration maxDelay_;
 
public:
    explicit ExponentialBackoffStrategy(Retry::Delays delays);
 
private:
    [[nodiscard]] std::chrono::steady_clock::duration
    nextDelay() const override;
};

Retry
makeRetryExponentialBackoff(
    Retry::Delays delays,
    boost::asio::strand<boost::asio::io_context::executor_type> strand
);

Retry
makeRetryExponentialBackoff(Retry::Delays delays, boost::asio::any_io_executor executor);
 
}  // namespace util