deploymentDaemonCmdsImpl.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_REUSABLECOMPONENT_DEPLOYMENT_DAEMONIMPL_HPP
#define RTCTK_REUSABLECOMPONENT_DEPLOYMENT_DAEMONIMPL_HPP
 
#include "deploymentDaemonEvents.rad.hpp"
#include <Rtctkif.hpp>
 
#include <rtctk/componentFramework/commandReplier.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/malEventInjector.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
 
#include <mal/Cii.hpp>
 
#include <memory>
#include <string>
 
namespace rtctk::deploymentDaemon {
 
namespace cfw = rtctk::componentFramework;
 
class DeploymentCmdsImpl : public rtctkif::AsyncDeploymentCmds {
public:
    static void Register(cfw::CommandReplier& replier, cfw::StateMachineEngine& engine) {
        std::shared_ptr<elt::mal::rr::RrEntity> rr_service =
            std::make_shared<DeploymentCmdsImpl>(engine);
        replier.RegisterService<rtctkif::AsyncDeploymentCmds>("DeploymentCmds", rr_service);
    }
 
    explicit DeploymentCmdsImpl(cfw::StateMachineEngine& engine)
        : m_logger(cfw::GetLogger("rtctk")), m_engine(engine) {
    }
 
    ::elt::mal::future<std::string> Deploy(std::string const& deploy_set) override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Deploy' with deploy_set '" + deploy_set);
        auto ev = std::make_shared<deployment_daemon_events::Deploy>(deploy_set);
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
    ::elt::mal::future<std::string> Undeploy() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Undeploy'");
        auto ev = std::make_shared<deployment_daemon_events::Undeploy>();
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
    ::elt::mal::future<std::string> GetActiveDeployment() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetActiveDeployment'");
        return cfw::InjectReqRepEvent<deployment_daemon_events::GetActiveDeployment>(m_engine);
    }
 
    ::elt::mal::future<std::string> GetDescription() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetDescription'");
        return cfw::InjectReqRepEvent<deployment_daemon_events::GetDescription>(m_engine);
    }
 
    ::elt::mal::future<std::vector<std::string>> GetDeploymentSets() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetDeploymentSets'");
        auto ev = std::make_shared<deployment_daemon_events::GetDeploymentSets>();
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
    ::elt::mal::future<std::vector<std::string>> GetComponents() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetComponents'");
        auto ev = std::make_shared<deployment_daemon_events::GetComponents>();
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
    ::elt::mal::future<std::vector<std::string>> GetActiveComponents() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetActiveComponents'");
        auto ev = std::make_shared<deployment_daemon_events::GetActiveComponents>();
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
    ::elt::mal::future<std::string> StartComponent(std::string const& component_name) override {
        LOG4CPLUS_TRACE(m_logger,
                        "Received command 'StartComponent' with component_name'" + component_name);
        auto ev = std::make_shared<deployment_daemon_events::StartComponent>(component_name);
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
    ::elt::mal::future<std::string> StopComponent(std::string const& component_name) override {
        LOG4CPLUS_TRACE(m_logger,
                        "Received command 'StopComponent' with component_name'" + component_name);
        auto ev = std::make_shared<deployment_daemon_events::StopComponent>(component_name);
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
    ::elt::mal::future<std::string> GetState() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'GetState'");
        return cfw::InjectReqRepEvent<deployment_daemon_events::GetState>(m_engine);
    }
 
    ::elt::mal::future<std::string> Reset() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Reset'");
        return cfw::InjectReqRepEvent<deployment_daemon_events::Reset>(m_engine);
    }
 
    ::elt::mal::future<std::string> Exit() override {
        LOG4CPLUS_TRACE(m_logger, "Received command 'Exit'");
        return cfw::InjectReqRepEvent<deployment_daemon_events::Exit>(m_engine);
    }
 
    ::elt::mal::future<std::string>
    SetLogLevel(std::shared_ptr<rtctkif::LogInfo> const& info) override {
        LOG4CPLUS_TRACE(m_logger,
                        "Received command 'SetLogLevel' with logger '" + info->getLogger() +
                            "' and level '" + info->getLevel() + "'");
        auto ev = std::make_shared<deployment_daemon_events::SetLogLevel>(info->clone());
        auto f = ev->GetPayload().GetReplyFuture();
        m_engine.PostEvent(ev);
        return f;
    }
 
private:
    log4cplus::Logger& m_logger;
    cfw::StateMachineEngine& m_engine;
};
 
}  // namespace rtctk::deploymentDaemon
 
#endif  // RTCTK_REUSABLECOMPONENT_DEPLOYMENT_DAEMONIMPL_HPP