supervisory.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_RTCSUPERVISOR_SUPERVISORY_HPP
#define RTCTK_RTCSUPERVISOR_SUPERVISORY_HPP
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/jsonPayload.hpp>
#include <rtctk/componentFramework/rtcComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
#include <rtctk/rtcSupervisor/supervisoryCmdsImpl.hpp>
 
namespace rtctk::rtcSupervisor {
 
using namespace rtctk::componentFramework;
 
namespace detail {
class SetModesContext {
public:
    explicit SetModesContext(const rad::cii::Request<std::string, std::string>& request)
        : m_logger(GetLogger("rtctk")), m_request(request), m_arg() {
        m_arg = JsonPayload::parse(m_request.GetRequestPayload());
    }
    SetModesContext(SetModesContext&&) noexcept = default;

    const JsonPayload& GetArg() const noexcept {
        return m_arg;
    }

    void SendReply() noexcept {
        try {
            m_request.SetReplyValue(STD_OK_REPLY);
        } catch (const std::exception& exception) {
            LOG4CPLUS_ERROR(
                m_logger, "SetModesContext::SendReply: Failed to send reply: " << exception.what());
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "SetModesContext::SendReply: Failed to send reply with unknown exception.");
        }
    }

    void SendErrorReply(std::exception_ptr eptr) noexcept {
        try {
            m_request.SetException(RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "SetModesContext::SendErrorReply: Failed to send reply with unknown exception.");
        }
    }
 
private:
    log4cplus::Logger& m_logger;

    rad::cii::Request<std::string, std::string> m_request;
    JsonPayload m_arg;
};

class WriteBackContext {
public:
    explicit WriteBackContext(const rad::cii::Request<std::string, std::string>& request)
        : m_logger(GetLogger("rtctk")), m_request(request), m_arg() {
        m_arg = JsonPayload::parse(m_request.GetRequestPayload());
    }
    WriteBackContext(WriteBackContext&&) noexcept = default;

    const JsonPayload& GetArg() const noexcept {
        return m_arg;
    }

    void SendReply() noexcept {
        try {
            m_request.SetReplyValue(STD_OK_REPLY);
        } catch (const std::exception& exception) {
            LOG4CPLUS_ERROR(
                m_logger,
                "WriteBackContext::SendReply: Failed to send reply: " << exception.what());
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "WriteBackContext::SendReply: Failed to send reply with unknown exception.");
        }
    }

    void SendErrorReply(std::exception_ptr eptr) noexcept {
        try {
            m_request.SetException(RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "WriteBackContext::SendErrorReply: Failed to send reply with unknown exception.");
        }
    }

    void SendStopReply() noexcept {
        try {
            m_request.SetException(StdIfRequestAborted());
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "SetModesContext::SendStopReply: Failed to send reply with unknown exception.");
        }
    }
 
private:
    log4cplus::Logger& m_logger;

    rad::cii::Request<std::string, std::string> m_request;
    JsonPayload m_arg;
};
}  // namespace detail

template <typename Super>
struct Supervisory : Super {
    static_assert(std::is_base_of_v<RtcComponent, Super>, "'Supervisory' requires 'RtcComponent'");

    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual std::string ActionGetStatus() {
            return {};
        }

        virtual void ActivitySettingModes(StopToken st, const JsonPayload& arg) {
        }

        virtual bool GuardSettingModesAllowed(const JsonPayload& arg) {
            return true;
        }

        virtual void ActionSetDeferredModes(const JsonPayload& arg) {
        }

        virtual JsonPayload ActionGetAvailableModes() {
            return {};
        }

        virtual JsonPayload ActionGetActiveModes() {
            return {};
        }

        virtual JsonPayload ActionGetDeferredModes() {
            return {};
        }

        virtual void ActivityWritingBack(StopToken st, const JsonPayload& arg) {
        }

        virtual bool GuardWritingBackAllowed(const JsonPayload& arg) {
            return true;
        }

        virtual void ActivityRecovering(StopToken st) {
        }
    };

    class InputStage : public Super::InputStage {
    public:
        using Super::InputStage::InputStage;
 
        void Start() override {
            Super::InputStage::Start();
 
            RecoverCmdsImpl::Register(this->m_replier, this->m_engine);
            ModeCmdsImpl::Register(this->m_replier, this->m_engine);
            WriteBackCmdsImpl::Register(this->m_replier, this->m_engine);
        }
    };

    class OutputStage : public Super::OutputStage {
    public:
        OutputStage(StateMachineEngine& engine, BizLogicIf& bl) : Super::OutputStage(engine, bl) {
            // Handlers ###################################################################
 
            engine.RegisterRejectHandler<events::SetModes, RequestRejected>();
            engine.RegisterRejectHandler<events::SetDeferredModes, RequestRejected>();
            engine.RegisterRejectHandler<events::GetDeferredModes, RequestRejected>();
            engine.RegisterRejectHandler<events::GetAvailableModes, RequestRejected>();
            engine.RegisterRejectHandler<events::GetActiveModes, RequestRejected>();
            engine.RegisterRejectHandler<events::WriteBack, RequestRejected>();
            engine.RegisterRejectHandler<events::Recover, RequestRejected>();
 
            m_setmode_success_handler = [this] {
                this->m_engine.PostEvent(std::make_unique<events::SetModesDone>());
            };
 
            m_setmode_error_handler = [this](std::exception_ptr eptr) {
                this->m_engine.PostEvent(std::make_unique<events::SetModesError>(std::move(eptr)));
            };
 
            m_writeback_success_handler = [this] {
                this->m_engine.PostEvent(std::make_unique<events::WriteBackDone>());
            };
 
            m_writeback_error_handler = [this](std::exception_ptr eptr) {
                this->m_engine.PostEvent(std::make_unique<events::WriteBackError>(std::move(eptr)));
            };
 
            // No Disable in states ###############################################################
 
            this->m_no_disable_in_states.emplace_back("On:SetModes:Busy");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.emplace_back("On:SetModes:Busy");
 
            // No SetModes in states ##############################################################
 
            this->m_no_setmode_in_states.emplace_back("On:Update:Busy");
            this->m_no_setmode_in_states.emplace_back("On:WriteBack:Busy");
            this->m_no_setmode_in_states.emplace_back("On::NotOperational::Starting");
            this->m_no_setmode_in_states.emplace_back("On::NotOperational::NotReady");
            this->m_no_setmode_in_states.emplace_back("On::NotOperational::Initialising");
            this->m_no_setmode_in_states.emplace_back("On::NotOperational::Enabling");
            this->m_no_setmode_in_states.emplace_back("On::NotOperational::Disabling");
            this->m_no_setmode_in_states.emplace_back("On::Operational::Error");
            this->m_no_setmode_in_states.emplace_back("On::Operational::Recovering");
 
            // No WriteBack in states #############################################################
 
            this->m_no_writeback_in_states.emplace_back("On::NotOperational::Starting");
            this->m_no_writeback_in_states.emplace_back("On::NotOperational::NotReady");
            this->m_no_writeback_in_states.emplace_back("On::NotOperational::Initialising");
            this->m_no_writeback_in_states.emplace_back("On::NotOperational::Enabling");
            this->m_no_writeback_in_states.emplace_back("On::NotOperational::Disabling");
            this->m_no_writeback_in_states.emplace_back("On:SetModes:Busy");
 
            // Guards #####################################################################
 
            engine.RegisterGuardStatic<events::SetModes>(
                "GuardSettingModesAllowed", [this](const events::SetModes& ev) -> bool {
                    auto act_state = this->m_engine.GetState();
                    for (auto& s : m_no_setmode_in_states) {
                        if (act_state.find(s) != std::string::npos) {
                            return false;
                        }
                    }
                    detail::SetModesContext ctx(ev.GetPayload());
                    if (static_cast<BizLogicIf&>(this->m_logic)
                            .GuardSettingModesAllowed(ctx.GetArg())) {
                        // SetModes is allowed so context is stored.
                        // If there's an active context (and correspondingly an active
                        // request being processed something have gone terribly wrong)
                        assert(!m_setmode_ctx);
                        m_setmode_ctx.emplace(std::move(ctx));
                        return true;
                    }
                    return false;
                });
 
            engine.RegisterGuardStatic<events::WriteBack>(
                "GuardWritingBackAllowed", [this](const events::WriteBack& ev) -> bool {
                    auto act_state = this->m_engine.GetState();
                    for (auto& s : m_no_writeback_in_states) {
                        if (act_state.find(s) != std::string::npos) {
                            return false;
                        }
                    }
                    detail::WriteBackContext ctx(ev.GetPayload());
                    if (static_cast<BizLogicIf&>(this->m_logic)
                            .GuardWritingBackAllowed(ctx.GetArg())) {
                        // WriteBack is allowed so context is stored.
                        // If there's an active context (and correspondingly an active
                        // request being processed something have gone terribly wrong)
                        assert(!m_writeback_ctx);
                        m_writeback_ctx.emplace(std::move(ctx));
                        return true;
                    }
                    return false;
                });
 
            // Activities #####################################################################
 
            engine.RegisterActivity(
                "ActivitySettingModes",
                [this](StopToken stop_token) {
                    assert(m_setmode_ctx);
                    static_cast<BizLogicIf&>(this->m_logic)
                        .ActivitySettingModes(stop_token, m_setmode_ctx->GetArg());
                },
                m_setmode_success_handler,
                m_setmode_error_handler);
 
            engine.RegisterActivity(
                "ActivityWritingBack",
                [this](StopToken stop_token) {
                    assert(m_writeback_ctx);
                    static_cast<BizLogicIf&>(this->m_logic)
                        .ActivityWritingBack(stop_token, m_writeback_ctx->GetArg());
                },
                m_writeback_success_handler,
                m_writeback_error_handler);
 
            engine.RegisterActivity(
                "ActivityRecovering",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityRecovering(stop_token);
                },
                this->m_success_handler,
                this->m_error_handler);
 
            // Actions #####################################################################
 
            // override default implementation for ActionGetStatus in stdComponent.hpp
            engine.RegisterAction("ActionGetStatus", [this](auto c) {
                auto req = GetPayloadNothrow<events::GetStatus>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                auto status = static_cast<BizLogicIf&>(this->m_logic).ActionGetStatus();
                req->SetReplyValue(status);
            });
 
            engine.RegisterActionStatic<events::SetDeferredModes>(
                "ActionSetDeferredModes", [this](const events::SetDeferredModes& ev) {
                    auto req = GetPayloadNothrow<events::SetDeferredModes>(ev);
                    if (req == nullptr) {
                        // no event or request
                        return;
                    }
                    try {
                        auto json_arg = JsonPayload::parse(req->GetRequestPayload());
                        static_cast<BizLogicIf&>(this->m_logic).ActionSetDeferredModes(json_arg);
                        req->SetReplyValue(STD_OK_REPLY);
                    } catch (...) {
                        auto nested =
                            WrapWithNested(RtctkException("ActionSetDeferredModes: failed"));
                        auto eptr = std::make_exception_ptr(nested);
                        req->SetException(
                            RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
                        throw;  // to be caught in stateMachineEngine.cpp
                    }
                });
 
            engine.RegisterActionStatic<events::GetAvailableModes>(
                "ActionGetAvailableModes", [this](const events::GetAvailableModes& ev) {
                    auto req = GetPayloadNothrow<events::GetAvailableModes>(ev);
                    if (req == nullptr) {
                        // no event or request
                        return;
                    }
                    try {
                        auto result =
                            static_cast<BizLogicIf&>(this->m_logic).ActionGetAvailableModes();
                        req->SetReplyValue(result.dump());
                    } catch (...) {
                        auto nested =
                            WrapWithNested(RtctkException("ActionGetAvailableModes: failed"));
                        auto eptr = std::make_exception_ptr(nested);
                        req->SetException(
                            RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
                        throw;  // to be caught in stateMachineEngine.cpp
                    }
                });
 
            engine.RegisterActionStatic<events::GetActiveModes>(
                "ActionGetActiveModes", [this](const events::GetActiveModes& ev) {
                    auto req = GetPayloadNothrow<events::GetActiveModes>(ev);
                    if (req == nullptr) {
                        // no event or request
                        return;
                    }
                    try {
                        auto result =
                            static_cast<BizLogicIf&>(this->m_logic).ActionGetActiveModes();
                        req->SetReplyValue(result.dump());
                    } catch (...) {
                        auto nested =
                            WrapWithNested(RtctkException("ActionGetActiveModes: failed"));
                        auto eptr = std::make_exception_ptr(nested);
                        req->SetException(
                            RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
                        throw;  // to be caught in stateMachineEngine.cpp
                    }
                });
 
            engine.RegisterActionStatic<events::GetDeferredModes>(
                "ActionGetDeferredModes", [this](const events::GetDeferredModes& ev) {
                    auto req = GetPayloadNothrow<events::GetDeferredModes>(ev);
                    if (req == nullptr) {
                        // no event or request
                        return;
                    }
                    try {
                        auto result =
                            static_cast<BizLogicIf&>(this->m_logic).ActionGetDeferredModes();
                        req->SetReplyValue(result.dump());
                    } catch (...) {
                        auto nested =
                            WrapWithNested(RtctkException("ActionGetDeferredModes: failed"));
                        auto eptr = std::make_exception_ptr(nested);
                        req->SetException(
                            RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
                        throw;  // to be caught in stateMachineEngine.cpp
                    }
                });
 
            engine.RegisterActionStatic<events::SetModesDone>("ActionSettingModesDone",
                                                              [this](const events::SetModesDone&) {
                                                                  assert(m_setmode_ctx);
                                                                  m_setmode_ctx->SendReply();
                                                                  m_setmode_ctx.reset();
                                                              });
 
            engine.RegisterActionStatic<events::SetModesError>(
                "ActionSettingModesFailed", [this](const events::SetModesError& ev) {
                    m_setmode_ctx->SendErrorReply(ev.GetPayload());
                    m_setmode_ctx.reset();
                });
 
            engine.RegisterActionStatic<events::WriteBackDone>(
                "ActionWriteBackDone", [this](const events::WriteBackDone&) {
                    assert(m_writeback_ctx);
                    m_writeback_ctx->SendReply();
                    m_writeback_ctx.reset();
                });
 
            engine.RegisterActionStatic<events::WriteBackError>(
                "ActionWriteBackFailed", [this](const events::WriteBackError& ev) {
                    m_writeback_ctx->SendErrorReply(ev.GetPayload());
                    m_writeback_ctx.reset();
                });
 
            engine.RegisterActionStatic<events::Stop>(
                "ActionWriteBackStopped", [this](const events::Stop& ev) {
                    auto req = GetPayloadNothrow<events::Stop>(ev);
                    if (req == nullptr) {
                        // no event or request
                        return;
                    }
                    m_writeback_ctx->SendStopReply();
                    m_writeback_ctx.reset();
                    req->SetReplyValue(STD_OK_REPLY);
                });
 
            engine.RegisterAction("ActionRecoveringEntry", [this](auto c) {
                this->m_tmp_request = GetPayloadNothrow<events::Recover>(c);
            });
 
            engine.RegisterAction("ActionRecoveringDone", [this](auto c) {
                if (this->m_tmp_request) {
                    this->m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    this->m_tmp_request = nullptr;
                }
            });
 
            engine.RegisterAction("ActionRecoveringFailed", [this](auto c) {
                if (auto eptr = GetPayloadNothrow<events::Error>(c); eptr) {
                    if (this->m_tmp_request) {
                        this->m_tmp_request->SetException(
                            RequestFailed{NestedExceptionPrinter{*eptr}.Str()});
                        this->m_tmp_request = nullptr;
                    }
                }
            });
        }
 
    protected:
        std::optional<detail::SetModesContext> m_setmode_ctx;
        std::optional<detail::WriteBackContext> m_writeback_ctx;
        std::function<void()> m_setmode_success_handler;
        std::function<void(std::exception_ptr)> m_setmode_error_handler;
        std::function<void()> m_writeback_success_handler;
        std::function<void(std::exception_ptr)> m_writeback_error_handler;
        std::list<std::string> m_no_setmode_in_states;
        std::list<std::string> m_no_writeback_in_states;
    };

    class ModelBuilder : public Super::ModelBuilder {
    public:
        explicit ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            // clang-format off
            this->mm.AddState(Composite, "On:SetModes",                 "On");
            this->mm.AddState(Initial,   "On:SetModes:Initial",         "On:SetModes");
            this->mm.AddState(Simple,    "On:SetModes:Idle",            "On:SetModes");
            this->mm.AddState(Simple,    "On:SetModes:Busy",            "On:SetModes",      "ActivitySettingModes");
            this->mm.AddState(Initial,   "On::Operational::Initial",    "On::Operational");
            this->mm.AddState(Simple,    "On::Operational::Idle",       "On::Operational");
            this->mm.AddState(Simple,    "On::Operational::Recovering", "On::Operational",  "ActivityRecovering", "ActionRecoveringEntry");
            this->mm.AddState(Simple,    "On::Operational::Error",      "On::Operational");
 
            this->mm.AddTrans("On",                              ""    , events::GetAvailableModes::ID, "", "ActionGetAvailableModes");
            this->mm.AddTrans("On::NotOperational::NotReady",    ""    , events::SetDeferredModes::ID, "", "ActionSetDeferredModes");
            this->mm.AddTrans("On::NotOperational::NotReady",    ""    , events::GetDeferredModes::ID, "", "ActionGetDeferredModes");
            this->mm.AddTrans("On::NotOperational::Ready",       ""    , events::SetDeferredModes::ID, "", "ActionSetDeferredModes");
            this->mm.AddTrans("On::NotOperational::Ready",       ""    , events::GetDeferredModes::ID, "", "ActionGetDeferredModes");
            this->mm.AddTrans("On::NotOperational::Ready",       ""    , events::GetActiveModes::ID, "", "ActionGetActiveModes");
            this->mm.AddTrans("On::NotOperational::Enabling",    ""    , events::GetActiveModes::ID, "", "ActionGetActiveModes");
            this->mm.AddTrans("On::Operational",                 ""    , events::GetActiveModes::ID, "", "ActionGetActiveModes");
 
            this->mm.AddTrans("On::Operational::Initial"       , "On::Operational::Idle"       );
            this->mm.AddTrans("On::Operational::Idle"          , "On::Operational::Recovering"    , "events.Recover");
            this->mm.AddTrans("On::Operational::Error"         , "On::Operational::Recovering"    , "events.Recover");
            this->mm.AddTrans("On::Operational::Recovering"    , "On::Operational::Idle"          , "events.Done",   "" ,"ActionRecoveringDone");
            this->mm.AddTrans("On::Operational::Recovering"    , "On::Operational::Error"         , "events.Error",  "" ,"ActionRecoveringFailed");
 
            this->mm.AddTrans("On:SetModes:Initial", "On:SetModes:Idle");
            this->mm.AddTrans("On:SetModes:Idle",    "On:SetModes:Busy", events::SetModes::ID, "GuardSettingModesAllowed");
            this->mm.AddTrans("On:SetModes:Busy",    "On:SetModes:Idle", events::SetModesDone::ID,  "", "ActionSettingModesDone");
            this->mm.AddTrans("On:SetModes:Busy",    "On:SetModes:Idle", events::SetModesError::ID, "", "ActionSettingModesFailed");
 
            this->mm.AddState(Composite, "On:WriteBack",  "On");
            this->mm.AddState(Initial,   "On:WriteBack:Initial", "On:WriteBack");
            this->mm.AddState(Simple,    "On:WriteBack:Idle",    "On:WriteBack");
            this->mm.AddState(Simple,    "On:WriteBack:Busy",    "On:WriteBack", "ActivityWritingBack");
 
            this->mm.AddTrans("On:WriteBack:Initial", "On:WriteBack:Idle");
            this->mm.AddTrans("On:WriteBack:Idle",    "On:WriteBack:Busy", events::WriteBack::ID, "GuardWritingBackAllowed");
            this->mm.AddTrans("On:WriteBack:Busy",    "On:WriteBack:Idle", events::WriteBackDone::ID,  "", "ActionWriteBackDone");
            this->mm.AddTrans("On:WriteBack:Busy",    "On:WriteBack:Idle", events::WriteBackError::ID, "", "ActionWriteBackFailed");
            this->mm.AddTrans("On:WriteBack:Busy",    "On:WriteBack:Idle", events::Stop::ID,           "", "ActionWriteBackStopped");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::rtcSupervisor
 
#endif