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/exceptions.hpp>
#include <rtctk/componentFramework/introspectionImpl.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/modelBuilderBase.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
#include <rtctk/componentFramework/stdCmdsImpl.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
#include <rtctk/componentFramework/utils.hpp>
 
#include <mal/Cii.hpp>
 
#include <memory>
#include <string>
 
namespace rtctk::componentFramework {
 
class LogInfo : public stdif::LogInfo {
public:
    LogInfo() = default;
 
    explicit LogInfo(std::string const& level, std::string const& logger = "")
        : m_logger(logger), m_level(level) {
    }
 
    std::string getLogger() const override {
        return m_logger;
    }
 
    void setLogger(std::string const& logger) override {
        m_logger = logger;
    }
 
    std::string getLevel() const override {
        return m_level;
    }
 
    void setLevel(std::string const& level) override {
        m_level = level;
    }
 
    bool hasKey() const override {
        return false;
    }
 
    bool keyEquals(stdif::LogInfo const& other) const override {
        return false;
    }
 
    std::unique_ptr<stdif::LogInfo> clone() const override {
        return std::make_unique<LogInfo>(m_logger, m_level);
    }
 
    std::unique_ptr<stdif::LogInfo> cloneKey() const override {
        return std::make_unique<LogInfo>(m_logger, m_level);
    }
 
private:
    std::string m_logger;
    std::string m_level;
};
 
 
// this we reply over MAL for commands that succeeds
inline const std::string STD_OK_REPLY = "OK";
 
 
// High level exception types returned via MAL
 
class StdIfRequestAborted : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 11;
    StdIfRequestAborted() : stdif::ExceptionErr("Request aborted.", ERROR_CODE) {
    }
};
 
class StdIfRequestRejected : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 10;
    StdIfRequestRejected(std::string const& request_id, std::string const& state_id)
        : stdif::ExceptionErr("Request " + request_id + " rejected in state " + state_id,
                              ERROR_CODE) {
    }
};
 
class StdIfRequestFailed : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 501;
    explicit StdIfRequestFailed(std::string const& message)
        : stdif::ExceptionErr(message, ERROR_CODE) {
    }
};
 
struct StdComponent {
    class BizLogicIf {
    public:
        virtual void ActivityStarting(StopToken st){};
        virtual void ActivityInitialising(StopToken){};
        virtual void ActivityEnabling(StopToken){};
        virtual void ActivityDisabling(StopToken){};
    };
 
    class InputStage {
    public:
        InputStage(CommandReplier& replier, StateMachineEngine& engine)
            : m_replier(replier), m_engine(engine) {
        }
 
        virtual ~InputStage() = default;
 
        virtual void Start() {
            // exit event is used by SIGTERM, SIGINT and SIGHUP
            m_engine.RegisterExitEvent(std::make_unique<events::Exit>());
            // stdif MAL commands
            StdCmdsImpl::Register(m_replier, m_engine);
            IntrospectionImpl::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, StdIfRequestRejected>();
            engine.RegisterRejectHandler<events::Stop, StdIfRequestRejected>();
            engine.RegisterRejectHandler<events::Reset, StdIfRequestRejected>();
            engine.RegisterRejectHandler<events::Enable, StdIfRequestRejected>();
            engine.RegisterRejectHandler<events::Disable, StdIfRequestRejected>();
            engine.RegisterRejectHandler<events::GetState, StdIfRequestRejected>();
            engine.RegisterRejectHandler<events::Exit, StdIfRequestRejected>();
 
            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>(std::move(eptr)));
            };
 
            // Reset ######################################################################
 
            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;
                }
            });
 
            // Init ######################################################################
 
            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(
                            StdIfRequestFailed{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(StdIfRequestAborted());
                    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(StdIfRequestAborted());
                    m_tmp_request = nullptr;
                }
                m_tmp_request = req;
            });
 
            // Enable ######################################################################
 
            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(
                            StdIfRequestFailed{NestedExceptionPrinter{*eptr}.Str()});
                        m_tmp_request = nullptr;
                    }
                }
            });
 
            // Disable #####################################################################
 
            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(
                            StdIfRequestFailed{NestedExceptionPrinter{*eptr}.Str()});
                        m_tmp_request = nullptr;
                    }
                }
            });
 
            // 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());
            });
 
            // GetStatus #####################################################################
 
            engine.RegisterAction("ActionGetStatus", [this](auto c) {
                auto req = GetPayloadNothrow<events::GetStatus>(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;
                }
                auto loginfo = req->GetRequestPayload();
                auto selected_logger = loginfo->getLogger();
                auto& logger = GetLogger(selected_logger);
                log4cplus::LogLevelManager llm;
                auto selected_ll = llm.fromString(loginfo->getLevel());
                if (selected_ll == log4cplus::NOT_SET_LOG_LEVEL) {
                    req->SetException(StdIfRequestFailed("Invalid LogLevel specified"));
                } else {
                    logger.setLogLevel(selected_ll);
                    LOG4CPLUS_INFO(GetLogger("rtctk"),
                                   "Log Level of logger '" << loginfo->getLogger() << "' set to '"
                                                           << llm.toString(logger.getLogLevel())
                                                           << "'");
                    req->SetReplyValue(STD_OK_REPLY);
                }
            });
 
            // Activities #####################################################################
 
            m_engine.RegisterActivity(
                "ActivityStarting",
                [this](StopToken stop_token) { m_logic.ActivityStarting(stop_token); },
                m_success_handler,
                m_error_handler);
 
            m_engine.RegisterActivity(
                "ActivityInitialising",
                [this](StopToken stop_token) { m_logic.ActivityInitialising(stop_token); },
                m_success_handler,
                m_error_handler);
 
            m_engine.RegisterActivity(
                "ActivityEnabling",
                [this](StopToken stop_token) { m_logic.ActivityEnabling(stop_token); },
                m_success_handler,
                m_error_handler);
 
            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:
        explicit ModelBuilder(StateMachineEngine& engine) : ModelBuilderBase(engine) {
            // clang-format off
            mm.AddState(Initial,   "Initial");
            mm.AddState(Parallel,  "On");
            mm.AddState(Final,     "Off");
 
            mm.AddState(Composite, "On:", "On");
            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.GetStatus",   ""   ,"ActionGetStatus");
            mm.AddTrans("On"                               , ""                                    , "events.GetVersion", ""    ,"ActionGetVersion");
            mm.AddTrans("On"                               , ""                                    , "events.SetLogLevel",""    ,"ActionSetLogLevel");
            mm.AddTrans("On"                               , "On"                                  , "events.Reset");
            mm.AddTrans("On::Initial"                      , "On::NotOperational");
 
            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");
 
            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");
 
            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"   );
 
            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");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_STDCOMPONENT_HPP