retry_policy.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <algorithm>
#include <cmath>
#include <functional>
#include <limits>
#include <string>
 
namespace kcenon::thread
{
    enum class retry_strategy
    {
        none,                
        fixed,               
        linear,              
        exponential_backoff  
    };
 
    class retry_policy
    {
    public:
        retry_policy()
            : strategy_(retry_strategy::none)
            , max_attempts_(1)
            , initial_delay_(std::chrono::milliseconds(0))
            , multiplier_(1.0)
            , max_delay_(std::chrono::milliseconds(0))
            , use_jitter_(false)
            , current_attempt_(0)
        {
        }
 
        [[nodiscard]] static auto no_retry() -> retry_policy
        {
            return retry_policy();
        }
 
        [[nodiscard]] static auto fixed(
            std::size_t max_attempts,
            std::chrono::milliseconds delay) -> retry_policy
        {
            retry_policy policy;
            policy.strategy_ = retry_strategy::fixed;
            policy.max_attempts_ = max_attempts;
            policy.initial_delay_ = delay;
            policy.multiplier_ = 1.0;
            policy.max_delay_ = delay;
            return policy;
        }
 
        [[nodiscard]] static auto linear(
            std::size_t max_attempts,
            std::chrono::milliseconds initial_delay,
            std::chrono::milliseconds max_delay = std::chrono::milliseconds::max()) -> retry_policy
        {
            retry_policy policy;
            policy.strategy_ = retry_strategy::linear;
            policy.max_attempts_ = max_attempts;
            policy.initial_delay_ = initial_delay;
            policy.multiplier_ = 1.0;
            policy.max_delay_ = max_delay;
            return policy;
        }
 
        [[nodiscard]] static auto exponential_backoff(
            std::size_t max_attempts,
            std::chrono::milliseconds initial_delay = std::chrono::milliseconds(100),
            double multiplier = 2.0,
            std::chrono::milliseconds max_delay = std::chrono::milliseconds(30000),
            bool use_jitter = false) -> retry_policy
        {
            retry_policy policy;
            policy.strategy_ = retry_strategy::exponential_backoff;
            policy.max_attempts_ = max_attempts;
            policy.initial_delay_ = initial_delay;
            policy.multiplier_ = multiplier;
            policy.max_delay_ = max_delay;
            policy.use_jitter_ = use_jitter;
            return policy;
        }
 
        [[nodiscard]] auto get_strategy() const -> retry_strategy
        {
            return strategy_;
        }
 
        [[nodiscard]] auto get_max_attempts() const -> std::size_t
        {
            return max_attempts_;
        }
 
        [[nodiscard]] auto get_initial_delay() const -> std::chrono::milliseconds
        {
            return initial_delay_;
        }
 
        [[nodiscard]] auto get_multiplier() const -> double
        {
            return multiplier_;
        }
 
        [[nodiscard]] auto get_max_delay() const -> std::chrono::milliseconds
        {
            return max_delay_;
        }
 
        [[nodiscard]] auto uses_jitter() const -> bool
        {
            return use_jitter_;
        }
 
        [[nodiscard]] auto is_retry_enabled() const -> bool
        {
            return strategy_ != retry_strategy::none && max_attempts_ > 1;
        }
 
        [[nodiscard]] auto get_current_attempt() const -> std::size_t
        {
            return current_attempt_;
        }
 
        [[nodiscard]] auto has_attempts_remaining() const -> bool
        {
            return current_attempt_ < max_attempts_ - 1;
        }
 
        auto record_attempt() -> void
        {
            ++current_attempt_;
        }
 
        auto reset() -> void
        {
            current_attempt_ = 0;
        }
 
        [[nodiscard]] auto get_delay_for_current_attempt() const -> std::chrono::milliseconds
        {
            if (strategy_ == retry_strategy::none || current_attempt_ == 0)
            {
                return std::chrono::milliseconds(0);
            }
 
            std::chrono::milliseconds delay;
 
            switch (strategy_)
            {
                case retry_strategy::fixed:
                    delay = initial_delay_;
                    break;
 
                case retry_strategy::linear:
                    delay = std::chrono::milliseconds(
                        initial_delay_.count() * static_cast<long long>(current_attempt_)
                    );
                    break;
 
                case retry_strategy::exponential_backoff:
                    {
                        double factor = std::pow(multiplier_, static_cast<double>(current_attempt_ - 1));
                        auto calculated = static_cast<long long>(
                            static_cast<double>(initial_delay_.count()) * factor
                        );
                        delay = std::chrono::milliseconds(calculated);
                    }
                    break;
 
                default:
                    delay = std::chrono::milliseconds(0);
                    break;
            }
 
            // Apply max_delay cap
            if (delay > max_delay_)
            {
                delay = max_delay_;
            }
 
            return delay;
        }
 
        [[nodiscard]] auto to_string() const -> std::string
        {
            switch (strategy_)
            {
                case retry_strategy::none:
                    return "retry_policy(none)";
                case retry_strategy::fixed:
                    return "retry_policy(fixed, attempts=" + std::to_string(max_attempts_) +
                           ", delay=" + std::to_string(initial_delay_.count()) + "ms)";
                case retry_strategy::linear:
                    return "retry_policy(linear, attempts=" + std::to_string(max_attempts_) +
                           ", initial=" + std::to_string(initial_delay_.count()) + "ms)";
                case retry_strategy::exponential_backoff:
                    return "retry_policy(exponential, attempts=" + std::to_string(max_attempts_) +
                           ", initial=" + std::to_string(initial_delay_.count()) +
                           "ms, multiplier=" + std::to_string(multiplier_) + ")";
                default:
                    return "retry_policy(unknown)";
            }
        }
 
    private:
        retry_strategy strategy_;
        std::size_t max_attempts_;
        std::chrono::milliseconds initial_delay_;
        double multiplier_;
        std::chrono::milliseconds max_delay_;
        bool use_jitter_;
        std::size_t current_attempt_;
    };
 
} // namespace kcenon::thread