deploymentDaemonLifeCycle.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_REUSABLECOMPONENT_DEPLOYMENT_DAEMON_LIFE_CYCLE_HPP
#define RTCTK_REUSABLECOMPONENT_DEPLOYMENT_DAEMON_LIFE_CYCLE_HPP
 
#include "deploymentDaemonCmdsImpl.hpp"
 
#include <rtctk/componentFramework/commandReplier.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/modelBuilderBase.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
 
#include <rtctk/componentFramework/exceptions.hpp>
 
#include <mal/Cii.hpp>
 
#include <memory>
#include <string>
 
namespace rtctk::deploymentDaemon {
 
using namespace rtctk::componentFramework;
 
 
// 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 DeploymentDaemonRequestAborted : public rtctkif::DeploymentException {
public:
    static constexpr int32_t ERROR_CODE = 11;
    DeploymentDaemonRequestAborted()
        : rtctkif::DeploymentException("Request aborted.", ERROR_CODE) {
    }
};
 
class NoDeployment : public rtctkif::DeploymentException {
public:
    static constexpr int32_t ERROR_CODE = 11;
    NoDeployment(std::string const& request_id, std::string const& state_id)
        : rtctkif::DeploymentException(
              "No active deployment. (Request " + request_id + " rejected in state " + state_id,
              ERROR_CODE) {
    }
};
 
class DeploymentAlreadyExists : public rtctkif::DeploymentException {
public:
    static constexpr int32_t ERROR_CODE = 12;
    DeploymentAlreadyExists(std::string const& request_id, std::string const& state_id)
        : rtctkif::DeploymentException("Active deployment already exists. (Request " + request_id +
                                           " rejected in state " + state_id,
                                       ERROR_CODE) {
    }
};
 
class DeploymentDaemonRequestRejected : public rtctkif::DeploymentException {
public:
    static constexpr int32_t ERROR_CODE = 10;
    DeploymentDaemonRequestRejected(std::string const& request_id, std::string const& state_id)
        : rtctkif::DeploymentException("Request " + request_id + " rejected in state " + state_id,
                                       ERROR_CODE) {
    }
};
 
class DeploymentDaemonRequestFailed : public rtctkif::DeploymentException {
public:
    static constexpr int32_t ERROR_CODE = 501;
    explicit DeploymentDaemonRequestFailed(std::string const& message)
        : rtctkif::DeploymentException(message, ERROR_CODE) {
    }
};
 
struct DeploymentDaemonLifeCycle {
    class BizLogicIf {
    public:
        virtual void ActivityDeploying(cfw::StopToken st, std::string args) = 0;
        virtual void ActivityUndeploying(cfw::StopToken st) = 0;
 
        virtual std::string ActionGetActiveDeployment() = 0;
        virtual std::string ActionGetDescription() = 0;
 
        virtual std::vector<std::string> ActionGetDeploymentSets() = 0;
 
        virtual std::vector<std::string> ActionGetComponents() = 0;
        virtual std::vector<std::string> ActionGetActiveComponents() = 0;
 
        virtual void ActionStartComponent(std::string args) = 0;
        virtual void ActionStopComponent(std::string args) = 0;
 
        virtual void ActivityStarting(cfw::StopToken st) = 0;
    };
 
    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<deployment_daemon_events::Exit>());
            // deployment daemon MAL commands
            DeploymentCmdsImpl::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 ###################################################################
 
            // clang-format off
            engine.RegisterRejectHandler<deployment_daemon_events::Reset, DeploymentDaemonRequestRejected>();
            engine.RegisterRejectHandler<deployment_daemon_events::GetState, DeploymentDaemonRequestRejected>();
            engine.RegisterRejectHandler<deployment_daemon_events::Exit, DeploymentDaemonRequestRejected>();
 
            engine.RegisterRejectHandler<deployment_daemon_events::Deploy, DeploymentAlreadyExists>();
            engine.RegisterRejectHandler<deployment_daemon_events::Undeploy, NoDeployment>();
            engine.RegisterRejectHandler<deployment_daemon_events::GetActiveDeployment, NoDeployment>();
            engine.RegisterRejectHandler<deployment_daemon_events::GetDescription, NoDeployment>();
            engine.RegisterRejectHandler<deployment_daemon_events::GetDeploymentSets, NoDeployment>();
            engine.RegisterRejectHandler<deployment_daemon_events::GetComponents, NoDeployment>();
            engine.RegisterRejectHandler<deployment_daemon_events::GetActiveComponents, NoDeployment>();
 
            engine.RegisterRejectHandler<deployment_daemon_events::StartComponent, NoDeployment>();
            engine.RegisterRejectHandler<deployment_daemon_events::StopComponent, NoDeployment>();
            // clang-format on
 
            m_custom_success_handler = [this] {
                m_engine.PostEvent(std::make_unique<deployment_daemon_events::Done>());
            };
 
            m_custom_error_handler = [this](const std::exception_ptr& eptr) {
                m_engine.PostEvent(std::make_unique<deployment_daemon_events::Error>(eptr));
            };
 
            engine.RegisterActionStatic<deployment_daemon_events::Deploy>(
                "ActionDeployEntry", [this](auto const& ev) {
                    assert(not m_tmp_deploy_request);
                    m_tmp_deploy_request = ev.GetPayload();
                });
 
            engine.RegisterActionStatic<deployment_daemon_events::Done>(
                "ActionDeployDone", [this](auto const&) {
                    assert(m_tmp_deploy_request);
                    m_tmp_deploy_request->SetReplyValue(STD_OK_REPLY);
                    m_tmp_deploy_request.reset();
                });
            engine.RegisterActionStatic<deployment_daemon_events::Error>(
                "ActionDeployFailed", [this](auto const& ev) {
                    auto const& eptr = ev.GetPayload();
                    assert(m_tmp_deploy_request);
                    m_tmp_deploy_request->SetException(
                        DeploymentDaemonRequestFailed{NestedExceptionPrinter{eptr}.Str()});
                    m_tmp_deploy_request.reset();
                });
 
            engine.RegisterActionStatic<deployment_daemon_events::Undeploy>(
                "ActionUndeployEntry", [this](auto const& ev) {
                    assert(not m_tmp_undeploy_request);
                    m_tmp_undeploy_request = ev.GetPayload();
                });
 
            engine.RegisterActionStatic<deployment_daemon_events::Done>(
                "ActionUndeployDone", [this](auto const&) {
                    assert(m_tmp_undeploy_request);
                    m_tmp_undeploy_request->SetReplyValue(STD_OK_REPLY);
                    m_tmp_undeploy_request.reset();
                });
 
            engine.RegisterActionStatic<deployment_daemon_events::Error>(
                "ActionUndeployFailed", [this](auto const& ev) {
                    auto const& eptr = ev.GetPayload();
                    assert(m_tmp_undeploy_request);
                    m_tmp_undeploy_request->SetException(
                        DeploymentDaemonRequestFailed{NestedExceptionPrinter{eptr}.Str()});
                    m_tmp_undeploy_request.reset();
                });
 
            // Activities #####################################################################
 
            engine.RegisterActivity(
                "ActivityDeploying",
                [this](StopToken stop_token) {
                    std::string arg = m_tmp_deploy_request->GetRequestPayload();
                    //                    JsonPayload arg = JsonPayload::parse(args);
                    static_cast<BizLogicIf&>(this->m_logic).ActivityDeploying(stop_token, arg);
                },
                m_custom_success_handler,
                m_custom_error_handler);
 
            engine.RegisterActivity(
                "ActivityUndeploying",
                [this](StopToken stop_token) {
                    static_cast<BizLogicIf&>(this->m_logic).ActivityUndeploying(stop_token);
                },
                m_custom_success_handler,
                m_custom_error_handler);
 
            // Reset ######################################################################
 
            engine.RegisterAction("ActionStartingEntry", [this](auto c) {
                m_tmp_request = GetPayloadNothrow<deployment_daemon_events::Reset>(c);
            });
 
            engine.RegisterAction("ActionStartingDone", [this](auto c) {
                if (m_tmp_request) {
                    m_tmp_request->SetReplyValue(STD_OK_REPLY);
                    m_tmp_request = nullptr;
                }
            });
 
            // Exit #####################################################################
 
            engine.RegisterAction("ActionExit", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_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<deployment_daemon_events::GetState>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(m_engine.GetState());
            });
 
            // SetLogLevel #####################################################################
 
            engine.RegisterAction("ActionSetLogLevel", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_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(DeploymentDaemonRequestFailed("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);
                }
            });
 
            engine.RegisterAction("ActionGetActiveDeployment", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_events::GetActiveDeployment>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(
                    static_cast<BizLogicIf&>(this->m_logic).ActionGetActiveDeployment());
            });
 
            engine.RegisterAction("ActionGetDescription", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_events::GetDescription>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(static_cast<BizLogicIf&>(this->m_logic).ActionGetDescription());
            });
 
            engine.RegisterAction("ActionStartComponent", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_events::StartComponent>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                std::string arg = req->GetRequestPayload();
                try {
                    static_cast<BizLogicIf&>(this->m_logic).ActionStartComponent(arg);
                    req->SetReplyValue(STD_OK_REPLY);
                } catch (const std::exception& eptr) {
                    req->SetException(rtctkif::DeploymentException(
                        "ActionStartComponent failed: " + std::string(eptr.what()), 601));
                }
            });
 
            engine.RegisterAction("ActionStopComponent", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_events::StopComponent>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                std::string arg = req->GetRequestPayload();
                try {
                    static_cast<BizLogicIf&>(this->m_logic).ActionStopComponent(arg);
                    req->SetReplyValue(STD_OK_REPLY);
                } catch (const std::exception& eptr) {
                    req->SetException(rtctkif::DeploymentException(
                        "ActionStopComponent failed: " + std::string(eptr.what()), 602));
                }
            });
 
            engine.RegisterAction("ActionGetDeploymentSets", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_events::GetDeploymentSets>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(
                    static_cast<BizLogicIf&>(this->m_logic).ActionGetDeploymentSets());
            });
 
            engine.RegisterAction("ActionGetComponents", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_events::GetComponents>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(static_cast<BizLogicIf&>(this->m_logic).ActionGetComponents());
            });
 
            engine.RegisterAction("ActionGetActiveComponents", [this](auto c) {
                auto req = GetPayloadNothrow<deployment_daemon_events::GetActiveComponents>(c);
                if (req == nullptr) {
                    // no event or request
                    return;
                }
                req->SetReplyValue(
                    static_cast<BizLogicIf&>(this->m_logic).ActionGetActiveComponents());
            });
 
            // Activities #####################################################################
 
            m_engine.RegisterActivity(
                "ActivityStarting",
                [this](StopToken stop_token) { m_logic.ActivityStarting(stop_token); },
                m_custom_success_handler,
                m_custom_error_handler);
        }
 
        virtual ~OutputStage() = default;
 
    protected:
        StateMachineEngine& m_engine;
        BizLogicIf& m_logic;
        std::optional<rad::cii::Request<std::string>> m_tmp_undeploy_request;
        std::optional<rad::cii::Request<std::string, std::string>> m_tmp_deploy_request;
 
        std::shared_ptr<rad::cii::Request<std::string, void>> m_tmp_request;
        std::function<void()> m_custom_success_handler;
        std::function<void(std::exception_ptr)> m_custom_error_handler;
    };
 
    class ModelBuilder : public ModelBuilderBase {
    public:
        explicit ModelBuilder(StateMachineEngine& engine) : ModelBuilderBase(engine) {
            // clang-format off
            mm.AddState(Initial,    "Initial");
            mm.AddState(Composite,  "On");
            mm.AddState(Final,      "Off");
            mm.AddState(Initial,    "On::Initial",       "On");
            mm.AddState(Simple,     "On::Starting",      "On", "ActivityStarting",    "ActionStartingEntry");
            mm.AddState(Simple,     "On::NotDeployed",   "On");
            mm.AddState(Simple,     "On::Deployed",      "On");
            mm.AddState(Simple,     "On::Deploying",     "On", "ActivityDeploying",   "ActionDeployEntry");
            mm.AddState(Simple,     "On::Undeploying",   "On", "ActivityUndeploying", "ActionUndeployEntry");
 
            mm.AddTrans("Initial",        "On");
            mm.AddTrans("On",             "Off",            "deployment_daemon_events.Exit",                 "", "ActionExit");
            mm.AddTrans("On",             "On",             "deployment_daemon_events.Reset");
            mm.AddTrans("On",             "",               "deployment_daemon_events.GetState",             "", "ActionGetState");
            mm.AddTrans("On",             "",               "deployment_daemon_events.SetLogLevel",          "", "ActionSetLogLevel");
 
            mm.AddTrans("On::Initial",     "On::Starting");
            mm.AddTrans("On::Starting",    "On::NotDeployed", "deployment_daemon_events.Done",               "", "ActionStartingDone");
            mm.AddTrans("On::NotDeployed", "On::Deploying",   "deployment_daemon_events.Deploy",             "", "");
            mm.AddTrans("On::Deploying",   "On::Deployed",    "deployment_daemon_events.Done",               "", "ActionDeployDone");
            mm.AddTrans("On::Deploying",   "On::NotDeployed", "deployment_daemon_events.Error",              "", "ActionDeployFailed");
            mm.AddTrans("On::Deployed",    "On::Undeploying", "deployment_daemon_events.Undeploy",           "", "");
            mm.AddTrans("On::Undeploying", "On::NotDeployed", "deployment_daemon_events.Done",               "", "ActionUndeployDone");
            mm.AddTrans("On::Undeploying", "On::NotDeployed", "deployment_daemon_events.Error",              "", "ActionUndeployFailed");
 
            mm.AddTrans("On",              "",               "deployment_daemon_events.GetDeploymentSets",   "", "ActionGetDeploymentSets");
            mm.AddTrans("On::Deployed",    "",               "deployment_daemon_events.GetActiveDeployment", "", "ActionGetActiveDeployment");
            mm.AddTrans("On::Deployed",    "",               "deployment_daemon_events.GetDescription",      "", "ActionGetDescription");
            mm.AddTrans("On::Deployed",    "",               "deployment_daemon_events.GetComponents",       "", "ActionGetComponents");
            mm.AddTrans("On::Deployed",    "",               "deployment_daemon_events.GetActiveComponents", "", "ActionGetActiveComponents");
            mm.AddTrans("On::Deployed",    "",               "deployment_daemon_events.StartComponent",      "", "ActionStartComponent");
            mm.AddTrans("On::Deployed",    "",               "deployment_daemon_events.StopComponent",       "", "ActionStopComponent");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::deploymentDaemon
 
#endif  // RTCTK_REUSABLECOMPONENT_DEPLOYMENT_DAEMON_LIFE_CYCLE_HPP