actor_base.h

#pragma once
 
//
// Copyright (c) 2019-2024 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "forward.hpp"
#include "address.hpp"
#include "actor_config.h"
#include "messages.hpp"
#include "state.h"
#include "handler.h"
#include "extended_error.h"
#include "timer_handler.hpp"
#include <set>
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
namespace rotor {
 
struct ROTOR_API actor_base_t : public arc_base_t<actor_base_t> {
    using config_t = actor_config_t;
 
    template <typename Actor> using config_builder_t = actor_config_builder_t<Actor>;
 
    template <typename Handler>
    using is_handler =
        std::enable_if_t<std::is_member_function_pointer_v<Handler> || std::is_base_of_v<handler_base_t, Handler>>;
 
    // clang-format off
    using plugins_list_t = std::tuple<
        plugin::address_maker_plugin_t,
        plugin::lifetime_plugin_t,
        plugin::init_shutdown_plugin_t,
        plugin::link_server_plugin_t,
        plugin::link_client_plugin_t,
        plugin::registry_plugin_t,
        plugin::resources_plugin_t,
        plugin::starter_plugin_t>;
    // clang-format on
 
    actor_base_t(config_t &cfg);
    virtual ~actor_base_t();
 
    virtual void do_initialize(system_context_t *ctx) noexcept;
 
    virtual void do_shutdown(const extended_error_ptr_t &reason = {}) noexcept;
 
    virtual void on_start() noexcept;
 
    template <typename M, typename... Args> void send(const address_ptr_t &addr, Args &&...args);
 
    template <typename R, typename... Args>
    request_builder_t<typename request_wrapper_t<R>::request_t> request(const address_ptr_t &dest_addr, Args &&...args);
 
    template <typename R, typename... Args>
    request_builder_t<typename request_wrapper_t<R>::request_t>
    request_via(const address_ptr_t &dest_addr, const address_ptr_t &reply_addr, Args &&...args);
 
    template <typename Request, typename... Args> void reply_to(Request &message, Args &&...args);
 
    template <typename Request> void reply_with_error(Request &message, const extended_error_ptr_t &ec);
 
    template <typename Request, typename... Args> auto make_response(Request &message, Args &&...args);
 
    template <typename Request> auto make_response(Request &message, const extended_error_ptr_t &ec);
 
    template <typename Handler> subscription_info_ptr_t subscribe(Handler &&h, const address_ptr_t &addr) noexcept;
 
    template <typename Handler> subscription_info_ptr_t subscribe(Handler &&h) noexcept;
 
    template <typename Handler, typename = is_handler<Handler>>
    void unsubscribe(Handler &&h, address_ptr_t &addr) noexcept;
 
    template <typename Handler, typename = is_handler<Handler>> void unsubscribe(Handler &&h) noexcept;
 
    /* \brief initiates handler unsubscription from the address
     *
     * If the address is local, then unsubscription confirmation is sent immediately,
     * otherwise {@link payload::external_subscription_t} request is sent to the external
     * supervisor, which owns the address.
     *
     * The optional call can be provided to be called upon message destruction.
     *
     */
 
    inline void unsubscribe(const handler_ptr_t &h) noexcept { lifetime->unsubscribe(h, address); }
 
    void activate_plugins() noexcept;
 
    void commit_plugin_activation(plugin::plugin_base_t &plugin, bool success) noexcept;
 
    void deactivate_plugins() noexcept;
 
    void commit_plugin_deactivation(plugin::plugin_base_t &plugin) noexcept;
 
    void on_subscription(message::subscription_t &message) noexcept;
 
    void on_unsubscription(message::unsubscription_t &message) noexcept;
 
    void on_unsubscription_external(message::unsubscription_external_t &message) noexcept;
 
    address_ptr_t create_address() noexcept;
 
    virtual void shutdown_start() noexcept;
 
    void shutdown_continue() noexcept;
 
    virtual void shutdown_finish() noexcept;
 
    virtual void init_start() noexcept;
 
    void init_continue() noexcept;
 
    virtual void init_finish() noexcept;
 
    virtual void configure(plugin::plugin_base_t &plugin) noexcept;
 
    template <typename T> auto &access() noexcept;
 
    template <typename T, typename... Args> auto access(Args... args) noexcept;
 
    template <typename T> auto &access() const noexcept;
 
    template <typename T, typename... Args> auto access(Args... args) const noexcept;
 
    inline const address_ptr_t &get_address() const noexcept { return address; }
 
    inline supervisor_t &get_supervisor() const noexcept { return *supervisor; }
 
    template <typename Delegate, typename Method,
              typename = std::enable_if_t<std::is_invocable_v<Method, Delegate *, request_id_t, bool>>>
    request_id_t start_timer(const pt::time_duration &interval, Delegate &delegate, Method method) noexcept;
 
    void cancel_timer(request_id_t request_id) noexcept;
 
    inline const extended_error_ptr_t &get_shutdown_reason() const noexcept { return shutdown_reason; }
 
    inline const std::string &get_identity() const noexcept { return identity; }
 
    static const constexpr std::uint32_t PROGRESS_INIT = 1 << 0;
 
    static const constexpr std::uint32_t PROGRESS_SHUTDOWN = 1 << 1;
 
    static const constexpr std::uint32_t ESCALATE_FALIURE = 1 << 2;
 
    static const constexpr std::uint32_t AUTOSHUTDOWN_SUPERVISOR = 1 << 3;
 
    virtual bool should_restart() const noexcept;
 
  protected:
    using timers_map_t = std::unordered_map<request_id_t, timer_handler_ptr_t>;
 
    using requests_t = std::unordered_set<request_id_t>;
 
    void on_timer_trigger(request_id_t request_id, bool cancelled) noexcept;
 
    template <typename Delegate, typename Method>
    void start_timer(request_id_t request_id, const pt::time_duration &interval, Delegate &delegate,
                     Method method) noexcept;
 
    void assign_shutdown_reason(extended_error_ptr_t reason) noexcept;
 
    extended_error_ptr_t make_error(const std::error_code &ec, const extended_error_ptr_t &next = {},
                                    const message_ptr_t &request = {}) const noexcept;
 
    virtual bool on_unlink(const address_ptr_t &server_addr) noexcept;
 
    intrusive_ptr_t<message::init_request_t> init_request;
 
    intrusive_ptr_t<message::shutdown_request_t> shutdown_request;
 
    address_ptr_t address;
 
    address_ptr_t spawner_address;
 
    std::string identity;
 
    supervisor_t *supervisor;
 
    plugin_storage_ptr_t plugins_storage;
 
    plugins_t plugins;
 
    pt::time_duration init_timeout;
 
    pt::time_duration shutdown_timeout;
 
    state_t state;
 
    plugin::address_maker_plugin_t *address_maker = nullptr;
 
    plugin::lifetime_plugin_t *lifetime = nullptr;
 
    plugin::link_server_plugin_t *link_server = nullptr;
 
    plugin::resources_plugin_t *resources = nullptr;
 
    plugin::plugin_base_t *get_plugin(const std::type_index &) const noexcept;
 
    std::set<const std::type_index *> activating_plugins;
 
    std::set<const std::type_index *> deactivating_plugins;
 
    timers_map_t timers_map;
 
    requests_t active_requests;
 
    std::uint32_t continuation_mask = 0;
 
    extended_error_ptr_t shutdown_reason;
 
    friend struct plugin::plugin_base_t;
    friend struct plugin::lifetime_plugin_t;
    friend struct supervisor_t;
    template <typename T> friend struct request_builder_t;
    template <typename T, typename M> friend struct accessor_t;
};
 
} // namespace rotor
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif