rtcComponent.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP
#define RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENT_HPP
 
#include "rtctk/componentFramework/detail/rtcComponent.hpp"
#include "rtctk/componentFramework/logger.hpp"
#include "rtctk/componentFramework/commandReplier.hpp"
#include "rtctk/componentFramework/commandHandler.hpp"
#include "rtctk/componentFramework/statePublisher.hpp"
#include "rtctk/componentFramework/runnableStateMachine.hpp"
#include "rtctk/componentFramework/serviceContainer.hpp"
#include "rtctk/componentFramework/serviceDiscovery.hpp"
#include "rtctk/componentFramework/fakeRuntimeRepoAdapter.hpp"
#include "rtctk/componentFramework/fakeOldbAdapter.hpp"
 
#include <mal/Cii.hpp>
#include <string>
#include <memory>
 
#include <type_traits>
 
namespace rtctk::componentFramework {
 
using Args = detail::Args;
 
template <class BusinessLogic>
class RtcComponent {
 
public:
    template<typename BusinessLogicFactory>
    RtcComponent(Args const& args, BusinessLogicFactory factory)
    {
        m_component_name = args.GetComponentName();
        LOG4CPLUS_INFO(GetLogger(), "RtcComponent '" << m_component_name << "' started.");
        LOG4CPLUS_DEBUG(GetLogger(), "BusinessLogic is '" << detail::GetTypeName(typeid(BusinessLogic)) << "'");
 
        auto svc_disc_endpoint = args.GetServiceDiscEndpoint();
        m_services.Add<ServiceDiscovery>(std::make_unique<ServiceDiscovery>(svc_disc_endpoint, m_component_name));
 
        ServiceDiscovery& svc_disc = m_services.Get<ServiceDiscovery>();
 
        auto rtr_endpoint = svc_disc.Get(ServiceDiscovery::RUNTIME_REPO_ENDPOINT);
        m_services.Add<RuntimeRepoApiIf>(std::make_unique<FakeRuntimeRepoAdapter>(rtr_endpoint));
 
        auto oldb_endpoint = svc_disc.Get(ServiceDiscovery::OLDB_ENDPOINT);
        m_services.Add<OldbApiIf>(std::make_unique<FakeOldbAdapter>(oldb_endpoint));
 
        auto req_rep_endpoint = svc_disc.Get(ServiceDiscovery::REQ_REP_ENDPOINT);
        m_replier = std::make_unique<CommandReplier>(req_rep_endpoint);
 
        auto pub_sub_endpoint = svc_disc.Get(ServiceDiscovery::PUB_SUB_ENDPOINT);
        m_publisher = std::make_unique<StatePublisher>(pub_sub_endpoint, m_component_name);
 
        // TODO: currently only one sm is supported, later solve this with traits and constexpr if
        static_assert(std::is_base_of_v<RunnableStateMachineLogicIf, BusinessLogic>,
                "BusinessLogic must implement RunnableStateMachineLogicIf");
 
        static_assert(std::is_invocable_v<BusinessLogicFactory, std::string const&, ServiceContainer&>,
                "Factory must be invocable with 'std::string const&' and 'ServiceContainer&'");
 
        static_assert(std::is_same_v<std::invoke_result_t<BusinessLogicFactory, std::string const&, ServiceContainer&>, std::unique_ptr<BusinessLogic>>,
                "Factory must return type 'std::unique_ptr<BusinessLogic>'");
 
        m_business_logic = std::invoke(factory, m_component_name, m_services);
        m_state_machine = std::make_unique<RunnableStateMachine>(*m_business_logic, [this](std::string const& state){OnStateChanged(state);});
        m_command_handler = std::make_unique<CommandHandler>(*m_replier, *m_state_machine);
    }
 
    RtcComponent(int argc, char *argv[])
    : RtcComponent(argc, argv, std::make_unique<BusinessLogic, std::string const&, ServiceContainer&>)
    {
        static_assert(std::is_constructible_v<BusinessLogic, std::string const&, ServiceContainer&>,
                "BusinessLogic must be constructible with 'std::string const&' and 'ServiceContainer&'");
    }
 
    RtcComponent(const RtcComponent& other) = delete;
    RtcComponent& operator= (const RtcComponent& other) = delete;
    RtcComponent(RtcComponent&& other) = delete;
    RtcComponent& operator= (const RtcComponent&& other) = delete;
 
    ~RtcComponent()
    {
        LOG4CPLUS_INFO(GetLogger(), "RtcComponent '" << m_component_name << "' terminated.");
    }
 
    void Run()
    {
        m_command_handler->Start();
        m_state_machine->Work();
    }
 
private:
 
    void OnStateChanged(const std::string& state) {
        m_publisher->PublishState(state);
 
        OldbApiIf& oldb = m_services.Get<OldbApiIf>();
        DataPointPath dp_name = DataPointPath("/" + m_component_name + "/state");
        if(not oldb.DataPointExists(dp_name)) {
            oldb.CreateDataPoint(dp_name, "RtcString");
        }
        oldb.SetDataPoint(dp_name, state);
    }
 
    std::string m_component_name;
    ServiceContainer m_services;
    std::unique_ptr<CommandReplier> m_replier;
    std::unique_ptr<StatePublisher> m_publisher;
    std::unique_ptr<BusinessLogic> m_business_logic;
    std::unique_ptr<RunnableStateMachine> m_state_machine;
    std::unique_ptr<CommandHandler> m_command_handler;
};
 
template <class BusinessLogic, class BusinessLogicFactory>
void RunAsRtcComponent(Args const& args, BusinessLogicFactory factory)
{
    RtcComponent<BusinessLogic> component{args, factory};
 
    component.Run();
}
 
template <class BusinessLogic>
void RunAsRtcComponent(Args const& args)
{
    static_assert(std::is_constructible_v<BusinessLogic, std::string const&, ServiceContainer&>,
            "BusinessLogic must be constructible with 'std::string const&' and 'ServiceContainer&'");
    RunAsRtcComponent<BusinessLogic>(args, std::make_unique<BusinessLogic, std::string const&, ServiceContainer&>);
}
 
} // closing namespace
 
void RtcComponentMain(rtctk::componentFramework::Args const& args);
 
 
#ifndef RTCTK_NOMAIN
int main(int argc, char *argv[])
{
    using namespace rtctk::componentFramework;
 
    LogInitializer initializer;
 
    try {
 
        Args args{argc, argv};
 
        auto component_name = args.GetComponentName();
        auto log_props_file = args.GetLogPropsFile();
 
        if(log_props_file.has_value()) {
            auto props_file = log_props_file.value().path().to_string();
            LogConfigure(props_file);
            SetDefaultLogger(component_name);
            LOG4CPLUS_INFO(GetLogger(), "Custom log properties file loaded: '" << props_file);
        }else {
            LogConfigure();
            MakeLogger(component_name, log4cplus::INFO_LOG_LEVEL);
            SetDefaultLogger(component_name);
        }
 
        RtcComponentMain(args);
 
        return EXIT_SUCCESS;
 
    }catch(detail::HelpOnly& e) {
        std::cout << e.what() << std::endl;
        return EXIT_SUCCESS;
    }catch(detail::ArgNotSet& e) {
        std::cout << e.what() << std::endl;
    }catch(std::exception& e) {
        LOG4CPLUS_FATAL(GetLogger(), e.what());
    }catch(...) {
        LOG4CPLUS_FATAL(GetLogger(), "Unknown exception occured!");
    }
    return EXIT_FAILURE;
}
#endif
 
#endif