stdComponent.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_STDCOMPONENT_HPP
#define RTCTK_COMPONENTFRAMEWORK_STDCOMPONENT_HPP
 
#include <rtctk/componentFramework/commandReplier.hpp>
#include <rtctk/componentFramework/events.rad.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/modelBuilderBase.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
#include <rtctk/componentFramework/stdBizLogicIf.hpp>
#include <rtctk/componentFramework/stdCmdsImpl.hpp>
#include <rtctk/componentFramework/utils.hpp>
#include <rtctk/componentFramework/exceptions.hpp>
 
#include <mal/Cii.hpp>
 
#include <memory>
#include <string>
 
namespace rtctk::componentFramework {
 
 
// this we reply over MAL for commands that succeeds
inline const std::string STD_OK_REPLY = "OK";
 
 
// High level excepiton types returned via MAL
 
// somebody send a stop or abort command
class RequestAborted : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 11;
    RequestAborted()
        : stdif::ExceptionErr("Request aborted.", ERROR_CODE) {
    }
};
 
// command is not allowed in current state or guard
class RequestRejected : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 10;
    RequestRejected(std::string const& request_id, std::string const& state_id)
        : stdif::ExceptionErr("Request " + request_id + " rejected in state " + state_id,
                              ERROR_CODE) {
    }
};
 
// the command was accepted but the task to do failed
class RequestFailed : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 501;
    RequestFailed(std::string const& message)
        : stdif::ExceptionErr(message, ERROR_CODE) {
    }
};
 
RTCTK_DEFINE_OPTION(UseStarting,     Disabled);
RTCTK_DEFINE_OPTION(UseInitialising, Enabled);
RTCTK_DEFINE_OPTION(UseEnabling,     Disabled);
RTCTK_DEFINE_OPTION(UseDisabling,    Disabled);
 
template <typename... Options>
struct StdComponent {
    struct AppliedOptions
        : RTCTK_APPLY_OPTION_ED(Options, UseStarting)
        , RTCTK_APPLY_OPTION_ED(Options, UseInitialising)
        , RTCTK_APPLY_OPTION_ED(Options, UseEnabling)
        , RTCTK_APPLY_OPTION_ED(Options, UseDisabling) {
    };
 
    RTCTK_ASSERT_OPTION_ED(UseStarting);
    RTCTK_ASSERT_OPTION_ED(UseInitialising);
    RTCTK_ASSERT_OPTION_ED(UseEnabling);
    RTCTK_ASSERT_OPTION_ED(UseDisabling);
 
    class BizLogicIf
        : public optional_base<IStarting,       RTCTK_IS_OPTION(UseStarting, Enabled)>
        , public optional_base<IInitialising,   RTCTK_IS_OPTION(UseInitialising, Enabled)>
        , public optional_base<IEnabling,       RTCTK_IS_OPTION(UseEnabling, Enabled)>
        , public optional_base<IDisabling,      RTCTK_IS_OPTION(UseDisabling, Enabled)> {
    };
 
    class InputStage {
    public:
        InputStage(CommandReplier& replier, StateMachineEngine& engine)
            : m_replier(replier), m_engine(engine) {
            // TODO should this also inject the events from the singal handler, e.g. SIGTERM
        }
 
        virtual ~InputStage() = default;
 
        virtual void Start() {
            StdCmdsImpl::Register(m_replier, m_engine);
        }
 
    protected:
        CommandReplier& m_replier;
        StateMachineEngine& m_engine;
    };
 
    class OutputStage {
    public:
 
        OutputStage(StateMachineEngine& engine, BizLogicIf& bl) : m_engine(engine), m_logic(bl) {
            // Handlers ###################################################################
 
            engine.RegisterRejectHandler<events::Init, RequestRejected>();
            engine.RegisterRejectHandler<events::Stop, RequestRejected>();
            engine.RegisterRejectHandler<events::Reset, RequestRejected>();
            engine.RegisterRejectHandler<events::Enable, RequestRejected>();
            engine.RegisterRejectHandler<events::Disable, RequestRejected>();
            engine.RegisterRejectHandler<events::GetState, RequestRejected>();
            engine.RegisterRejectHandler<events::Exit, RequestRejected>();
 
            m_success_handler = [this] { m_engine.PostEvent(std::make_unique<events::Done>()); };
 
            m_error_handler = [this](std::exception_ptr eptr) {
                m_engine.PostEvent(std::make_unique<events::Error>(eptr));
            };
 
            // Reset ######################################################################
 
            if constexpr (RTCTK_IS_OPTION(UseStarting, Enabled)) {
                engine.RegisterAction("ActionStartingEntry", [this](auto c) {
                    m_tmp_request = GetPayloadNothrow<events::Reset>(c);
                });
 
                engine.RegisterAction("ActionStartingDone", [this](auto c) {
                    if (m_tmp_request) {
                        m_tmp_request->SetReplyValue(STD_OK_REPLY);
                        m_tmp_request = nullptr;
                    }
                });
            } else {
                engine.RegisterAction("ActionStartingDone", [this](auto c) {
                    auto req = GetPayloadNothrow<events::Reset>(c);
                    if (req == nullptr) {
                        return;
                    }
                    req->SetReplyValue(STD_OK_REPLY);
                });
            }
 
            // Init ######################################################################
 
            if constexpr (RTCTK_IS_OPTION(UseInitialising, Enabled)) {
                engine.RegisterAction("ActionInitialisingEntry", [this](auto c) {
                    m_tmp_request = GetPayloadNothrow<events::Init>(c);
                });
 
                engine.RegisterAction("ActionInitialisingDone", [this](auto c) {
                    if (m_tmp_request) {
                        m_tmp_request->SetReplyValue(STD_OK_REPLY);
                        m_tmp_request = nullptr;
                    }
                });
 
                engine.RegisterAction("ActionInitialisingFailed", [this](auto c) {
                    if(auto eptr = GetPayloadNothrow<events::Error>(c); eptr) {
                        if (m_tmp_request) {
                            m_tmp_request->SetException(
                                RequestFailed(NestedExceptionPrinter(*eptr).Str()));
                            m_tmp_request = nullptr;
                        }
                    }
                });
 
                engine.RegisterAction("ActionInitialisingStopped", [this](auto c) {
                    auto req = GetPayloadNothrow<events::Stop>(c);
                    if (req == nullptr) {
                        // no event or request
                        return;
                    }
                    if (m_tmp_request) {
                        m_tmp_request->SetException(RequestAborted());
                        m_tmp_request = nullptr;
                    }
                    req->SetReplyValue(STD_OK_REPLY);
                });
 
                engine.RegisterAction("ActionInitialisingRestarted", [this](auto c) {
                    auto req = GetPayloadNothrow<events::Init>(c);
                    if (req == nullptr) {
                        // no event or request
                        return;
                    }
                    if (m_tmp_request) {
                        m_tmp_request->SetException(RequestAborted());
                        m_tmp_request = nullptr;
                    }
                    m_tmp_request = req;
                });
            } else {
                engine.RegisterAction("ActionInitialisingDone", [this](auto c) {
                    auto req = GetPayloadNothrow<events::Init>(c);
                    if (req == nullptr) {
                        return;
                    }
                    req->SetReplyValue(STD_OK_REPLY);
                });
            }
 
            // Enable ######################################################################
 
            if constexpr (RTCTK_IS_OPTION(UseEnabling, Enabled)) {
                engine.RegisterAction("ActionEnablingEntry", [this](auto c) {
                    m_tmp_request = GetPayloadNothrow<events::Enable>(c);
                });
 
                engine.RegisterAction("ActionEnablingDone", [this](auto c) {
                    if (m_tmp_request) {
                        m_tmp_request->SetReplyValue(STD_OK_REPLY);
                        m_tmp_request = nullptr;
                    }
                });
 
                engine.RegisterAction("ActionEnablingFailed", [this](auto c) {
                    if(auto eptr = GetPayloadNothrow<events::Error>(c); eptr) {
                        if (m_tmp_request) {
                            m_tmp_request->SetException(
                                RequestFailed(NestedExceptionPrinter(*eptr).Str()));
                            m_tmp_request = nullptr;
                        }
                    }
                });
            } else {
                engine.RegisterAction("ActionEnablingDone", [this](auto c) {
                    auto req = GetPayloadNothrow<events::Enable>(c);
                    if (req == nullptr) {
                        return;
                    }
                    req->SetReplyValue(STD_OK_REPLY);
                });
            }
 
            // Disable #####################################################################
 
            if constexpr (RTCTK_IS_OPTION(UseDisabling, Enabled)) {
                engine.RegisterAction("ActionDisablingEntry", [this](auto c) {
                    m_tmp_request = GetPayloadNothrow<events::Disable>(c);
                });
 
                engine.RegisterAction("ActionDisablingDone", [this](auto c) {
                    if (m_tmp_request) {
                        m_tmp_request->SetReplyValue(STD_OK_REPLY);
                        m_tmp_request = nullptr;
                    }
                });
 
                engine.RegisterAction("ActionDisablingFailed", [this](auto c) {
                    if(auto eptr = GetPayloadNothrow<events::Error>(c); eptr) {
                        if (m_tmp_request) {
                            m_tmp_request->SetException(
                                RequestFailed(NestedExceptionPrinter(*eptr).Str()));
                            m_tmp_request = nullptr;
                        }
                    }
                });
            } else {
                engine.RegisterAction("ActionDisablingDone", [this](auto c) {
                    auto req = GetPayloadNothrow<events::Disable>(c);
                    if (req == nullptr) {
                        return;
                    }
                    req->SetReplyValue(STD_OK_REPLY);
                });
            }
 
            // Exit #####################################################################
 
            engine.RegisterAction("ActionExit", [this](auto c) {
                auto req = GetPayloadNothrow<events::Exit>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(STD_OK_REPLY);
                m_engine.Stop();
            });
 
            // GetState #####################################################################
 
            engine.RegisterAction("ActionGetState", [this](auto c) {
                auto req = GetPayloadNothrow<events::GetState>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(m_engine.GetState());
            });
 
            // GetVersion #####################################################################
 
            engine.RegisterAction("ActionGetVersion", [this](auto c) {
                auto req = GetPayloadNothrow<events::GetVersion>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(VERSION);
            });
 
            // SetLogLevel #####################################################################
 
            engine.RegisterAction("ActionSetLogLevel", [this](auto c) {
                auto req = GetPayloadNothrow<events::SetLogLevel>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                std::string level = req->GetRequestPayload();
                auto& logger = GetLogger();
                log4cplus::LogLevelManager llm;
                logger.setLogLevel(llm.fromString(level));
                LOG4CPLUS_INFO(GetLogger(),
                               "Log Level set to " << llm.toString(logger.getLogLevel()));
                req->SetReplyValue(VERSION);
            });
 
            // Activities #####################################################################
 
            if constexpr (RTCTK_IS_OPTION(UseStarting, Enabled)) {
                m_engine.RegisterActivity("ActivityStarting",
                    [this](StopToken stop_token) {
                        m_logic.ActivityStarting(stop_token);
                    }, m_success_handler, m_error_handler);
            }
 
            if constexpr (RTCTK_IS_OPTION(UseInitialising, Enabled)) {
                m_engine.RegisterActivity("ActivityInitialising",
                    [this](StopToken stop_token) {
                        m_logic.ActivityInitialising(stop_token);
                    }, m_success_handler, m_error_handler);
            }
 
            if constexpr (RTCTK_IS_OPTION(UseEnabling, Enabled)) {
                m_engine.RegisterActivity("ActivityEnabling",
                    [this](StopToken stop_token) {
                        m_logic.ActivityEnabling(stop_token);
                    }, m_success_handler, m_error_handler);
            }
 
            if constexpr (RTCTK_IS_OPTION(UseDisabling, Enabled)) {
                m_engine.RegisterActivity("ActivityDisabling",
                    [this](StopToken stop_token) {
                        m_logic.ActivityDisabling(stop_token);
                    }, m_success_handler, m_error_handler);
            }
        }
 
        virtual ~OutputStage() = default;
 
    protected:
        StateMachineEngine& m_engine;
        BizLogicIf& m_logic;
        std::shared_ptr<rad::cii::Request<std::string, void>> m_tmp_request;
        std::function<void()> m_success_handler;
        std::function<void(std::exception_ptr)> m_error_handler;
    };
 
    class ModelBuilder : public ModelBuilderBase {
    public:
        ModelBuilder(StateMachineEngine& engine) : ModelBuilderBase(engine) {
            RegisterLayer({"StdComponent",
                           {
                               {"use_starting"     , RTCTK_IS_OPTION(UseStarting, Enabled)},
                               {"use_initialising" , RTCTK_IS_OPTION(UseInitialising, Enabled)},
                               {"use_enabling"     , RTCTK_IS_OPTION(UseEnabling, Enabled)},
                               {"use_disabling"    , RTCTK_IS_OPTION(UseDisabling, Enabled)},
                           }});
 
            mm.AddState(Initial,   "Initial");
            mm.AddState(Composite, "On");
            mm.AddState(Final,     "Off");
 
            mm.AddState(Initial,   "On.Initial",           "On");
            mm.AddState(Composite, "On.NotOperational",    "On");
            mm.AddState(Simple,    "On.Operational",       "On");
 
            mm.AddState(Initial,   "On.NotOperational.Initial",        "On.NotOperational");
            mm.AddState(Simple,    "On.NotOperational.NotReady",       "On.NotOperational");
            mm.AddState(Simple,    "On.NotOperational.Ready",          "On.NotOperational");
 
            mm.AddTrans("Initial"                          , "On");
            mm.AddTrans("On"                               , "Off"                                 , "events.Exit",       ""    ,"ActionExit");
            mm.AddTrans("On"                               , ""                                    , "events.GetState",   ""    ,"ActionGetState");
            mm.AddTrans("On"                               , ""                                    , "events.GetVersion", ""    ,"ActionGetVersion");
            mm.AddTrans("On"                               , ""                                    , "events.SetLogLevel",""    ,"ActionSetLogLevel");
            mm.AddTrans("On"                               , "On"                                  , "events.Reset");
            mm.AddTrans("On.Initial"                       , "On.NotOperational");
 
            if constexpr (RTCTK_IS_OPTION(UseStarting, Enabled)) {
                mm.AddState(Simple,    "On.NotOperational.Starting",       "On.NotOperational",    "ActivityStarting"          ,"ActionStartingEntry");
 
                mm.AddTrans("On.NotOperational.Initial"        , "On.NotOperational.Starting");
                mm.AddTrans("On.NotOperational.Starting"       , "On.NotOperational.NotReady"          , "events.Done",    ""   ,"ActionStartingDone");
            } else {
                mm.AddTrans("On.NotOperational.Initial"        , "On.NotOperational.NotReady"          , "",        ""          ,"ActionStartingDone");
            }
 
            if constexpr (RTCTK_IS_OPTION(UseInitialising, Enabled)) {
                mm.AddState(Simple,    "On.NotOperational.Initialising",   "On.NotOperational",    "ActivityInitialising"      ,"ActionInitialisingEntry");
 
                mm.AddTrans("On.NotOperational.NotReady"       , "On.NotOperational.Initialising"      , "events.Init");
                mm.AddTrans("On.NotOperational.Initialising"   , "On.NotOperational.Ready"             , "events.Done",    ""   ,"ActionInitialisingDone");
                mm.AddTrans("On.NotOperational.Initialising"   , "On.NotOperational.NotReady"          , "events.Error",   ""   ,"ActionInitialisingFailed");
                mm.AddTrans("On.NotOperational.Initialising"   , "On.NotOperational.NotReady"          , "events.Stop",    ""   ,"ActionInitialisingStopped");
                mm.AddTrans("On.NotOperational.Initialising"   , "On.NotOperational.Initialising"      , "events.Init",    ""   ,"ActionInitialisingRestarted");
                mm.AddTrans("On.NotOperational.Ready"          , "On.NotOperational.Initialising"      , "events.Init");
            } else {
                mm.AddTrans("On.NotOperational.NotReady"       , "On.NotOperational.Ready"             , "events.Init",    ""   ,"ActionInitialisingDone");
            }
 
            if constexpr (RTCTK_IS_OPTION(UseEnabling, Enabled)) {
                mm.AddState(Simple,    "On.NotOperational.Enabling",       "On.NotOperational",    "ActivityEnabling"          ,"ActionEnablingEntry");
 
                mm.AddTrans("On.NotOperational.Ready"          , "On.NotOperational.Enabling"       , "events.Enable");
                mm.AddTrans("On.NotOperational.Enabling"       , "On.Operational"                   , "events.Done",       ""   ,"ActionEnablingDone");
                mm.AddTrans("On.NotOperational.Enabling"       , "On.NotOperational.Ready"          , "events.Error",      ""   ,"ActionEnablingFailed");
                // TODO, do we want enabling to be stopable?
                //mm.AddTrans("On.NotOperational.Enabling"       , "On.NotOperational.Ready"          , "events.Stop"   );
            } else {
                mm.AddTrans("On.NotOperational.Ready"          , "On.Operational"                   , "events.Enable",     ""   ,"ActionEnablingDone");
            }
 
            if constexpr (RTCTK_IS_OPTION(UseDisabling, Enabled)) {
                mm.AddState(Simple,    "On.NotOperational.Disabling",      "On.NotOperational",    "ActivityDisabling"        ,"ActionDisablingEntry");
                mm.AddTrans("On.Operational"                   , "On.NotOperational.Disabling"      , "events.Disable");
                mm.AddTrans("On.NotOperational.Disabling"      , "On.NotOperational.Ready"          , "events.Done",     ""     ,"ActionDisablingDone");
                mm.AddTrans("On.NotOperational.Disabling"      , "On.NotOperational.Ready"          , "events.Error",    ""     ,"ActionDisablingFailed");
            } else {
                mm.AddTrans("On.Operational"                   , "On.NotOperational.Ready"          , "events.Disable",  ""     ,"ActionDisablingDone");
            }
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_STDCOMPONENT_HPP