retry.hpp

Go to the documentation of this file.

#pragma once
 
#include "concepts.hpp" // IWYU pragma: keep
#include "../detail/task_adapters/result_helpers.hpp"
 
namespace yorch {
 
struct retry_fixed_policy {
    std::size_t max_retries = 0;
 
    [[nodiscard]] constexpr bool should_retry(std::size_t retry_count) const noexcept {
        return retry_count < max_retries;
    }
 
    template <typename Raw>
    [[nodiscard]] static constexpr auto on_exhausted(Raw&& raw) noexcept {
        return detail::retry_exhausted_as_failure(std::forward<Raw>(raw));
    }
};
 
struct retry_fixed_passthrough_policy {
    std::size_t max_retries = 0;
 
    [[nodiscard]] constexpr bool should_retry(std::size_t retry_count) const noexcept {
        return retry_count < max_retries;
    }
 
    template <typename Raw>
    [[nodiscard]] static constexpr std::remove_cvref_t<Raw> on_exhausted(Raw&& raw) noexcept {
        return std::forward<Raw>(raw);
    }
};
 
struct retry_forever_policy {
    [[nodiscard]] static constexpr bool should_retry(std::size_t) noexcept {
        return true;
    }
};
 
template <typename Task, typename Policy>
struct retry_task
    : detail::retry_task_raw_result_base<Task>,
      detail::forwarded_task_output_base<Task>,
      detail::forwarded_task_output_protocol_base<Task> {
    Task task;
    Policy policy;
 
    constexpr retry_task(Task&& stored_task, Policy&& stored_policy)
        noexcept(std::is_nothrow_move_constructible_v<Task> &&
                 std::is_nothrow_move_constructible_v<Policy>)
        : task(std::move(stored_task)),
          policy(std::move(stored_policy)) {}
 
    constexpr retry_task(const Task& stored_task, const Policy& stored_policy)
        noexcept(std::is_nothrow_copy_constructible_v<Task> &&
                 std::is_nothrow_copy_constructible_v<Policy>)
        : task(stored_task),
          policy(stored_policy) {}
 
    template <typename Ctx, typename Prev>
        requires adapter_wrappable_task<Task, Ctx, Prev> && retry_policy<Policy>
    constexpr decltype(auto) invoke_raw(exec_context<Ctx, Prev>& ec)
        noexcept(noexcept(task.invoke_raw(ec)) &&
                 noexcept(policy.should_retry(std::size_t {})) &&
                 noexcept(detail::handle_retry_exhausted(
                     policy,
                     std::declval<std::remove_cvref_t<detail::raw_task_result_t<Task&, Ctx, Prev>>>()))) {
        using raw_result_t = detail::raw_task_result_t<Task&, Ctx, Prev>;
        using raw_value_t = std::remove_cvref_t<raw_result_t>;
 
        static_assert(detail::declared_task_raw_result_matches_invoke_raw_v<Task, Ctx, Prev>,
                      "Wrapped task raw_result_type must match invoke_raw(exec_context<...>&) return type");
 
        if constexpr (!detail::retry_status_capable_result_v<raw_result_t>) {
            return task.invoke_raw(ec);
        } else {
            static_assert(!std::is_reference_v<raw_result_t>,
                          "with_retry(...) does not support retry-capable reference raw results");
 
            std::size_t retry_count = 0;
 
            while (true) {
                raw_value_t raw = task.invoke_raw(ec);
 
                if (!detail::raw_result_requests_retry(raw)) {
                    return raw;
                }
 
                if (!policy.should_retry(retry_count)) {
                    return detail::handle_retry_exhausted(policy, std::move(raw));
                }
 
                ++retry_count;
            }
        }
    }
 
    template <typename Ctx, typename Prev, typename U = Task>
        requires direct_output_task<U, Ctx, Prev> && retry_policy<Policy>
    constexpr step_result invoke_into(
        exec_context<Ctx, Prev>& ec,
        direct_out<detail::declared_task_output_t<U>> out) noexcept(
            noexcept(task.invoke_into(ec, out)) &&
            noexcept(policy.should_retry(std::size_t {})) &&
            noexcept(detail::handle_retry_exhausted(
                policy,
                step_result::retry()))) {
        std::size_t retry_count = 0;
 
        while (true) {
            const auto step = task.invoke_into(ec, out);
 
            if (step.status != step_status::retry) {
                return step;
            }
 
            if (!policy.should_retry(retry_count)) {
                return detail::handle_retry_exhausted(policy, step);
            }
 
            // if the task requested retry, it should not have produced an output value, but just in case, destroy it before the next attempt to avoid leaking resources or causing double-destruction on the next success
            if (out.has_value()) {
                out.destroy();
            }
 
            ++retry_count;
        }
    }
};
 
template <typename Task, typename Policy>
    requires retry_policy<std::decay_t<Policy>>
constexpr auto with_retry(Task&& task, Policy&& policy) {
    return retry_task<
        std::decay_t<Task>,
        std::decay_t<Policy>
    >{
        std::forward<Task>(task),
        std::forward<Policy>(policy)
    };
}
 
}  // namespace yorch