retry.h

#pragma once
 
#include <ozo/failover/strategy.h>
#include <ozo/core/options.h>
 
namespace ozo::failover {
 
namespace detail {
 
template <typename TimeConstraint, typename Now = decltype(time_traits::now)>
inline auto get_try_time_constraint(TimeConstraint t, int n_tries, [[maybe_unused]] Now now = time_traits::now) {
    if constexpr (t == none) {
        return none;
    } else if constexpr (std::is_same_v<TimeConstraint, time_traits::time_point>) {
        return n_tries > 0 ? time_left(t, now()) / n_tries : time_traits::duration{0};
    } else {
        return n_tries > 0 ? t / n_tries : time_traits::duration{0};
    }
}
 
template <typename ...ErrorConditions>
constexpr auto make_errcs_tuple(ErrorConditions ...errcs) {
    return hana::make_tuple(errcs...);
}
 
} // namespace detail
 
struct retry_options {
    class on_retry_tag;
    class close_connection_tag;
    class tries_tag;
    class conditions_tag;
 
    constexpr static option<on_retry_tag> on_retry{}; 
    constexpr static option<close_connection_tag> close_connection{}; 
    constexpr static option<tries_tag> tries{}; 
    constexpr static option<conditions_tag> conditions{}; 
};
 
template <typename Options, typename Context>
class basic_try {
    Context ctx_;
    Options options_;
    using op = retry_options;
 
public:
    constexpr basic_try(Options options, Context ctx)
    : ctx_(std::move(ctx)), options_(std::move(options)) {
        static_assert(decltype(hana::is_a<hana::map_tag>(options))::value, "Options should be boost::hana::map");
    }
    constexpr basic_try(const basic_try&) = delete;
    constexpr basic_try(basic_try&&) = default;
    constexpr basic_try& operator = (const basic_try&) = delete;
    constexpr basic_try& operator = (basic_try&&) = default;
 
    constexpr const Options& options() const { return options_;}
    constexpr Options& options() { return options_;}
 
    auto get_context() const {
        return hana::concat(
            hana::make_tuple(ozo::unwrap(ctx_).provider, time_constraint()),
            ozo::unwrap(ctx_).args
        );
    }
 
    template <typename Connection>
    std::optional<basic_try> get_next_try(ozo::error_code ec, Connection&& conn) {
        auto guard = defer_close_connection(get_option(options(), op::close_connection, true) ? std::addressof(conn) : nullptr);
 
        std::optional<basic_try> retval;
        adjust_tries_remain();
        if (can_retry(ec)) {
            get_option(options(), op::on_retry, [](auto&&...){})(ec, conn);
            retval.emplace(basic_try{std::move(options_), std::move(ctx_)});
        }
 
        return retval;
    }
 
    constexpr int tries_remain() const { return get_option(options(), op::tries);}
 
    constexpr decltype(auto) get_conditions() const {
        return get_option(options(), op::conditions, no_conditions_);
    }
 
    auto time_constraint() const {
        return detail::get_try_time_constraint(ozo::unwrap(ctx_).time_constraint, tries_remain());
    }
 
private:
    void adjust_tries_remain() {
        options_[op::tries] = std::max(0, tries_remain() - 1);
    }
 
    bool can_retry([[maybe_unused]] error_code ec) const {
        if(tries_remain() < 1) {
            return false;
        }
 
        if constexpr (decltype(hana::is_empty(get_conditions()))::value) {
            return true;
        } else {
            return errc::match_code(get_conditions(), ec);
        }
    }
    constexpr static const auto no_conditions_ = hana::make_tuple();
};
 
 
template <typename Options = decltype(hana::make_map())>
class retry_strategy : public ozo::options_factory_base<retry_strategy<Options>, Options> {
    using op = retry_options;
 
    friend class ozo::options_factory_base<retry_strategy<Options>, Options>;
    using base = ozo::options_factory_base<retry_strategy<Options>, Options>;
 
    template <typename OtherOptions>
    constexpr static auto rebind_options(OtherOptions&& options) {
        return retry_strategy<std::decay_t<OtherOptions>>(std::forward<OtherOptions>(options));
    }
 
public:
    constexpr retry_strategy(Options options = Options{}) : base(std::move(options)) {
        static_assert(decltype(hana::is_a<hana::map_tag>(options))::value, "Options should be boost::hana::map");
    }
 
    template <typename Operation, typename Allocator, typename ConnectionProvider,
            typename TimeConstraint, typename ...Args>
    auto get_first_try(const Operation&, const Allocator&,
            ConnectionProvider&& provider, TimeConstraint t, Args&& ...args) const {
 
        static_assert(decltype(this->has(op::tries))::value, "number of tries should be specified");
 
        return basic_try {
            this->options(),
            basic_context{
                std::forward<ConnectionProvider>(provider),
                ozo::deadline(t),
                std::forward<Args>(args)...
            }
        };
    }
 
    constexpr decltype(auto) tries(int n) const & { return this->set(op::tries, n);}
    constexpr decltype(auto) tries(int n) && { return std::move(*this).set(op::tries, n);}
 
    constexpr int get_tries() const { return this->get(op::tries); }
 
    constexpr auto get_conditions() const { return this->get(op::conditions); }
 
    constexpr decltype(auto) operator * (int n) const & { return tries(n); }
    constexpr decltype(auto) operator * (int n) && { return std::move(*this).tries(n); }
};
 
template <typename ...Ts>
constexpr decltype(auto) operator * (int n, const retry_strategy<Ts...>& rs) { return rs * n;}
template <typename ...Ts>
constexpr decltype(auto) operator * (int n, retry_strategy<Ts...>&& rs) { return std::move(rs) * n;}
 
template <typename ...ErrorConditions>
constexpr auto retry(ErrorConditions ...ec) {
    if constexpr (sizeof...(ec) != 0) {
        return retry_strategy{}.set(retry_options::conditions=hana::make_tuple(ec...));
    } else {
        return retry_strategy{};
    }
}
 
} // namespace ozo::failover
 
namespace ozo {
 
template <typename ...Ts, typename Op>
struct construct_initiator_impl<failover::retry_strategy<Ts...>, Op>
: failover::construct_initiator_impl {};
 
} // namespace ozo