role_based.h

#pragma once
 
#include <ozo/failover/strategy.h>
#include <ozo/failover/retry.h>
#include <ozo/core/options.h>
#include <ozo/ext/std/optional.h>
#include <ozo/ext/std/nullopt_t.h>
 
#include <boost/hana/tuple.hpp>
#include <boost/hana/empty.hpp>
#include <boost/hana/size.hpp>
#include <boost/hana/minus.hpp>
#include <boost/hana/not_equal.hpp>
#include <boost/hana/greater.hpp>
 
namespace ozo::failover {
 
struct role_based_options {
    class on_fallback_tag;
    class close_connection_tag;
    class roles_tag;
 
    constexpr static option<on_fallback_tag> on_fallback{}; 
    constexpr static option<close_connection_tag> close_connection{}; 
    constexpr static option<roles_tag> roles{}; 
};
 
template <typename Tag>
using role = ozo::option<Tag>;
 
template <typename Role>
struct can_recover_impl {
    static constexpr std::false_type apply(const Role&, const error_code&) {
        static_assert(std::is_void_v<Role>, "no can_recover_impl specified for a given role");
        return {};
    }
};
 
constexpr role<class master_tag> master;
 
template <>
struct can_recover_impl<std::decay_t<decltype(master)>> {
    static constexpr auto value = hana::make_tuple(
        errc::connection_error,
        errc::type_mismatch,
        errc::protocol_error,
        errc::database_readonly
    );
 
    static constexpr auto apply(const std::decay_t<decltype(master)>&, const error_code& ec) {
        return errc::match_code(value, ec);
    }
};
 
constexpr role<class replica_tag> replica;
 
template <>
struct can_recover_impl<std::decay_t<decltype(replica)>> {
    static constexpr auto value = hana::make_tuple(
        errc::connection_error,
        errc::type_mismatch,
        errc::protocol_error
    );
 
    static constexpr auto apply(const std::decay_t<decltype(replica)>&, const error_code& ec) {
        return errc::match_code(value, ec);
    }
};
 
template <typename Role>
constexpr auto can_recover(const Role& role, const error_code& ec) {
    return can_recover_impl<Role>::apply(role, ec);
}
 
namespace detail {
 
template <typename Source, typename Role, typename = hana::when<true>>
struct connection_source_supports_role : std::false_type {};
 
template <typename Source, typename Role>
struct connection_source_supports_role <
    Source, Role,
    hana::when_valid<decltype(std::declval<Source>().rebind_role(std::declval<const Role&>()))>
> : std::true_type {};
 
} // namespace detail
 
template <typename Source>
class role_based_connection_provider {
    Source source_;
    io_context& io_;
public:
 
    static_assert(ozo::ConnectionSource<Source>, "Source should model a ConnectionSource concept");
    using source_type = std::decay_t<Source>;
 
    using connection_type = typename connection_source_traits<source_type>::connection_type;
 
    template <typename OtherRole>
    static constexpr auto is_supported(const OtherRole&) {
        return typename detail::connection_source_supports_role<source_type, OtherRole>::type{};
    }
 
    template <typename T>
    role_based_connection_provider(T&& source, io_context& io)
     : source_(std::forward<T>(source)), io_(io) {
    }
 
    template <typename OtherRole>
    constexpr decltype(auto) rebind_role(OtherRole r) const & {
        static_assert(is_supported(r), "role is not supported by a connection provider");
        using rebind_type = role_based_connection_provider<decltype(source_.rebind_role(r))>;
        return rebind_type{ozo::unwrap(source_).rebind_role(r), io_};
    }
 
    template <typename OtherRole>
    constexpr decltype(auto) rebind_role(OtherRole r) & {
        static_assert(is_supported(r), "role is not supported by a connection provider");
        using rebind_type = role_based_connection_provider<decltype(source_.rebind_role(r))>;
        return rebind_type{ozo::unwrap(source_).rebind_role(r), io_};
    }
 
    template <typename OtherRole>
    constexpr decltype(auto) rebind_role(OtherRole r) && {
        static_assert(is_supported(r), "role is not supported by a connection provider");
        using rebind_type = role_based_connection_provider<decltype(std::move(source_).rebind_role(r))>;
        return rebind_type{ozo::unwrap(std::forward<Source>(source_)).rebind_role(r), io_};
    }
 
    template <typename TimeConstraint, typename Handler>
    void async_get_connection(TimeConstraint t, Handler&& h) const & {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        ozo::unwrap(source_)(io_, std::move(t), std::forward<Handler>(h));
    }
 
    template <typename TimeConstraint, typename Handler>
    void async_get_connection(TimeConstraint t, Handler&& h) & {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        ozo::unwrap(source_)(io_, std::move(t), std::forward<Handler>(h));
    }
 
    template <typename TimeConstraint, typename Handler>
    void async_get_connection(TimeConstraint t, Handler&& h) && {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        ozo::unwrap(std::forward<Source>(source_))(io_, std::move(t), std::forward<Handler>(h));
    }
};
 
template <typename T>
role_based_connection_provider(T&& source, io_context& io) -> role_based_connection_provider<T>;
 
template <typename SourcesMap, typename Role>
struct role_based_connection_source {
    static_assert(decltype(hana::is_a<hana::map_tag>(std::declval<SourcesMap>()))::value, "SourcesMap should be a boost::hana::map");
    static_assert(decltype(hana::size(std::declval<const SourcesMap&>())!=hana::size_c<0>)::value, "sources should not be empty");
 
    SourcesMap sources_;
    Role role_;
 
    using source_type = std::decay_t<decltype(sources_[role_])>;
    using connection_type = typename connection_source_traits<source_type>::connection_type;
 
    template <typename OtherRole>
    static constexpr bool is_supported() {
        return decltype(hana::contains(std::declval<SourcesMap>(), std::declval<OtherRole>()))::value;
    }
 
    role_based_connection_source(SourcesMap sources, Role role)
    : sources_(std::move(sources)), role_(std::move(role)) {
        static_assert(is_supported<Role>(), "no default role found in sources");
    }
 
    template <typename OtherRole>
    constexpr auto rebind_role(OtherRole r) const & ->
            Require<is_supported<OtherRole>(), role_based_connection_source<SourcesMap, OtherRole>> {
        return {sources_, r};
    }
 
    template <typename OtherRole>
    constexpr auto rebind_role(OtherRole r) && ->
            Require<is_supported<OtherRole>(), role_based_connection_source<SourcesMap, OtherRole>> {
        return {std::move(sources_), r};
    }
 
    template <typename TimeConstraint, typename Handler>
    constexpr void operator() (io_context& io, TimeConstraint t, Handler&& h) const & {
        sources_[role_](io, std::move(t), std::forward<Handler>(h));
    }
 
    template <typename TimeConstraint, typename Handler>
    constexpr void operator() (io_context& io, TimeConstraint t, Handler&& h) & {
        sources_[role_](io, std::move(t), std::forward<Handler>(h));
    }
 
    template <typename TimeConstraint, typename Handler>
    constexpr void operator() (io_context& io, TimeConstraint t, Handler&& h) && {
        std::move(sources_[role_])(io, std::move(t), std::forward<Handler>(h));
    }
 
    constexpr auto operator[] (io_context& io) const & {
        return role_based_connection_provider(*this, io);
    }
 
    constexpr auto operator[] (io_context& io) & {
        return role_based_connection_provider(*this, io);
    }
 
    constexpr auto operator[] (io_context& io) && {
        return role_based_connection_provider(std::move(*this), io);
    }
};
 
template <typename Key, typename Value, typename ...Pairs>
constexpr decltype(auto) make_role_based_connection_source(hana::pair<Key, Value> p1, Pairs&& ...ps) {
    auto default_role = hana::first(p1);
    auto map = hana::make_map(std::move(p1), std::forward<Pairs>(ps)...);
    return role_based_connection_source{std::move(map), std::move(default_role)};
}
 
template <typename Options, typename Context, typename RoleIdx = decltype(hana::size_c<0>)>
class role_based_try {
    Context ctx_;
    Options options_;
    static constexpr RoleIdx idx_{};
    using opt = role_based_options;
 
public:
    constexpr role_based_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 role_based_try(const role_based_try&) = delete;
    constexpr role_based_try(role_based_try&&) = default;
    constexpr role_based_try& operator = (const role_based_try&) = delete;
    constexpr role_based_try& operator = (role_based_try&&) = default;
 
    constexpr const Options& options() const { return options_;}
    constexpr Options& options() { return options_;}
 
    static constexpr auto role_index() { return idx_;}
 
    constexpr auto role() const { return roles_seq()[role_index()];}
 
    auto get_context() const {
        return hana::concat(
            hana::make_tuple(ozo::unwrap(ctx_).provider.rebind_role(role()), time_constraint()),
            ozo::unwrap(ctx_).args
        );
    }
 
    auto time_constraint() const {
        return detail::get_try_time_constraint(ozo::unwrap(ctx_).time_constraint, tries_left().value);
    }
 
    constexpr decltype(auto) roles_seq() const {
        return get_option(options(), opt::roles);
    }
 
    constexpr auto tries_left() const {
        return decltype(hana::size(roles_seq()) - role_index()){};
    }
 
    template <typename Connection, typename Initiator>
    void initiate_next_try([[maybe_unused]] ozo::error_code ec, Connection& conn, [[maybe_unused]] Initiator&& init) const {
        auto guard = defer_close_connection(get_option(options(), opt::close_connection, true) ? std::addressof(conn) : nullptr);
 
        if constexpr (decltype(tries_left() > hana::size_c<1>)::value) {
            using fallback_try = role_based_try<Options, Context, decltype(role_index() + hana::size_c<1>)>;
            fallback_try fallback{std::move(options_), std::move(ctx_)};
 
            if (can_recover(fallback.role(), ec)) {
                get_option(fallback.options(), opt::on_fallback, [](auto&&...){})(ec, conn, std::as_const(fallback));
                init(std::move(fallback));
            } else {
                guard.release();
                fallback.initiate_next_try(ec, conn, std::move(init));
            }
        }
    }
};
 
template <typename Options, typename Context, typename RoleIdx>
struct initiate_next_try_impl<role_based_try<Options, Context, RoleIdx>> {
    template <typename Connection, typename Initiator>
    static void apply(role_based_try<Options, Context, RoleIdx>& a_try,
            const error_code& ec, Connection& conn, Initiator&& init) {
        a_try.initiate_next_try(ec, conn, std::forward<Initiator>(init));
    }
};
 
template <typename Options = decltype(hana::make_map())>
class role_based_strategy : public options_factory_base<role_based_strategy<Options>, Options> {
    using opt = role_based_options;
 
    friend class ozo::options_factory_base<role_based_strategy<Options>, Options>;
    using base = ozo::options_factory_base<role_based_strategy<Options>, Options>;
 
    template <typename OtherOptions>
    constexpr static auto rebind_options(OtherOptions&& options) {
        return role_based_strategy<std::decay_t<OtherOptions>>(std::forward<OtherOptions>(options));
    }
 
public:
    constexpr role_based_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 Source,
            typename TimeConstraint, typename ...Args>
    auto get_first_try(const Operation&, const Allocator&,
            role_based_connection_provider<Source> provider, TimeConstraint t, Args&& ...args) const {
 
        static_assert(decltype(this->has(opt::roles))::value, "roles should be specified");
        static_assert(!decltype(hana::is_empty(this->get(opt::roles)))::value, "roles should not be empty");
 
        return role_based_try {
            this->options(),
            basic_context{std::move(provider), ozo::deadline(t), std::forward<Args>(args)...}
        };
    }
};
 
template <typename ...Roles>
constexpr auto role_based(Roles ...roles) {
    if constexpr (sizeof...(roles) != 0) {
        return role_based_strategy{hana::make_map(role_based_options::roles=hana::make_tuple(roles...))};
    } else {
        return role_based_strategy{};
    }
}
 
} // namespace ozo::failover
 
namespace ozo {
 
template <typename ...Ts, typename Op>
struct construct_initiator_impl<failover::role_based_strategy<Ts...>, Op>
: failover::construct_initiator_impl {};
 
} // namespace ozo