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 {
 
class LogInfo : public stdif::LogInfo {
public:
 
  LogInfo() = default;
 
  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 excepiton types returned via MAL
 
// somebody send a stop or abort command
class StdIfRequestAborted : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 11;
    StdIfRequestAborted()
        : stdif::ExceptionErr("Request aborted.", ERROR_CODE) {
    }
};
 
// command is not allowed in current state or guard
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) {
    }
};
 
// the command was accepted but the task to do failed
class StdIfRequestFailed : public stdif::ExceptionErr {
public:
    static constexpr int32_t ERROR_CODE = 501;
    StdIfRequestFailed(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, 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>(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(
                                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;
                });
            } 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(
                                StdIfRequestFailed(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(
                                StdIfRequestFailed(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());
            });
 
            // 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(),
                                   "Log Level of logger '" << loginfo->getLogger() <<
                                   "' set to '" << llm.toString(logger.getLogLevel()) << "'");
                    req->SetReplyValue(STD_OK_REPLY);
                }
            });
 
            // 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.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");
 
            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