rtcComponentMain.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENTMAIN_HPP
#define RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENTMAIN_HPP
 
#include <rtctk/componentFramework/alertService.hpp>
#include <rtctk/componentFramework/commandReplier.hpp>
#include <rtctk/componentFramework/componentMetrics.hpp>
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/malDdsEventService.hpp>
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/rtcComponentArgs.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
#include <rtctk/componentFramework/serviceDiscovery.hpp>
#include <rtctk/componentFramework/serviceRegistryIf.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
#include <rtctk/componentFramework/statePublisher.hpp>
 
#include <mal/Cii.hpp>
 
#include <boost/core/demangle.hpp>
 
#include <iostream>
#include <memory>
#include <string>
 
void RtcComponentMain(rtctk::componentFramework::Args const& args);
 
namespace rtctk::componentFramework {
 
template <class BL, class BLF>
void RunAsRtcComponent(Args const& args, BLF factory) {
    try {
        auto& logger = GetLogger("rtctk");
 
        auto component_name = args.GetComponentName();
        LOG4CPLUS_INFO(logger, "RtcComponent '" << component_name << "' started.");
        using boost::core::demangle;
        LOG4CPLUS_DEBUG(logger, "BusinessLogic '" << demangle(typeid(BL).name()) << "'");
 
        {
            ServiceContainer services;
 
            // Service Discovery
            auto svc_disc_endpoint = args.GetServiceDiscEndpoint();
            services.Add<ServiceDiscovery>(
                std::make_unique<ServiceDiscovery>(svc_disc_endpoint, component_name));
            ServiceDiscovery& svc_disc = services.Get<ServiceDiscovery>();
 
            // Runtime repository
            auto rtr_endpoint = svc_disc.GetRuntimeRepoEndpoint();
            auto rtr_adapter = std::shared_ptr(RuntimeRepoIf::CreateAdapter(rtr_endpoint));
            services.Add<RuntimeRepoIf>(rtr_adapter);
 
            // OLDB
            auto oldb_endpoint = svc_disc.GetOldbEndpoint();
            auto oldb_adapter = std::shared_ptr(OldbIf::CreateAdapter(oldb_endpoint));
            services.Add<OldbIf>(oldb_adapter);
 
            // Telemetry service
            auto component_metrics = std::make_shared<ComponentMetrics>(
                oldb_adapter,
                DataPointPath("/") / DataPointPath(component_name) /
                    DataPointPath("metrics/default"),
                logger);
            services.Add<ComponentMetricsIf>(component_metrics);
            ComponentMetricsConfigurator component_metrics_configurator(
                component_metrics,
                rtr_adapter,
                DataPointPath("/") / DataPointPath(component_name) /
                    DataPointPath("dynamic/metrics/default"),
                logger);
 
            // Event Service
            auto event_service = std::make_shared<MalDdsEventService>();
            services.Add<EventServiceIf>(event_service);
 
            // Alert service and standard observers
            auto alert_service = std::make_shared<AlertService>(logger);
            AlertLogger alert_logger(logger, *alert_service);
            AlertEventPublisher alert_publisher(
                component_name, *alert_service, *event_service, logger);
            services.Add<AlertServiceIf>(alert_service);
 
            // for RR endpoint we do not want to be checked if the process is there or not (as we
            // are just starting it up)
            auto rr_endpoint = svc_disc.GetReqRepEndpoint("", false);
            CommandReplier replier(rr_endpoint);
 
            // ... and sam for PubSub endpoint we do not want to be checked if the process is there
            // or not (as we are just starting it up)
            auto ps_endpoint = svc_disc.GetPubSubEndpoint("", false);
            StatePublisher publisher(ps_endpoint, component_name);
 
            StateMachineEngine engine;
 
            engine.RegisterStateChangeHandler([&](std::string const& state) {
                try {
                    LOG4CPLUS_DEBUG(logger, "Entering State: " << state);
                    publisher.PublishState(state);
                    OldbIf& oldb = services.Get<OldbIf>();
                    DataPointPath dp_name = DataPointPath("/" + component_name + "/state");
                    if (not oldb.DataPointExists(dp_name)) {
                        oldb.CreateDataPoint<std::string>(dp_name);
                    }
                    oldb.SetDataPoint(dp_name, state);
                } catch (...) {
                    LOG4CPLUS_ERROR(logger,
                                    NestedExceptionPrinter(WrapWithNested(
                                        RtctkException("StateChangeHandler failed"))));
                }
            });
 
            static_assert(std::is_base_of_v<typename BL::ComponentType::BizLogicIf, BL>,
                          "BusinessLogic must implement BusinessLogicInterface");
 
            static_assert(
                std::is_invocable_v<BLF, std::string const&, ServiceContainer&>,
                "Factory must be invocable with 'std::string const&' and 'ServiceContainer&'");
 
            static_assert(
                std::is_same_v<std::invoke_result_t<BLF, std::string const&, ServiceContainer&>,
                               std::unique_ptr<BL>>,
                "Factory must return type 'std::unique_ptr<BusinessLogic>'");
 
            // Invoking user factory here -> catch and rethrow RtctkException
            std::unique_ptr<BL> biz_logic;
            try {
                biz_logic = invoke(factory, component_name, services);
                if (!biz_logic) {
                    CII_THROW(RtctkException,
                              "BusinessLogic factory did not return a valid object");
                }
            } catch (std::exception const& ex) {
                CII_THROW_WITH_NESTED(RtctkException, ex, "BusinessLogic factory failed");
            }
 
            typename BL::ComponentType::InputStage input_stage(replier, engine);
 
            typename BL::ComponentType::OutputStage output_stage(engine, *biz_logic);
 
            typename BL::ComponentType::ModelBuilder model_builder(engine);
 
            if (auto emf = args.GetModelExportFile(); emf) {
                model_builder.ExportModel(emf->path().to_string());
            }
 
            model_builder.RegisterModel();
            input_stage.Start();
            component_metrics->StartMonitoring();
            engine.Work();
        }
 
        LOG4CPLUS_INFO(logger, "RtcComponent '" << component_name << "' terminated.");
 
    } catch (std::exception const& ex) {
        CII_THROW_WITH_NESTED(RtctkException, ex, "RunAsRtcComponent() failed");
    }
}
 
template <class BL>
void RunAsRtcComponent(Args const& args) {
    static_assert(
        std::is_constructible_v<BL, std::string const&, ServiceContainer&>,
        "BusinessLogic must be constructible with 'std::string const&' and 'ServiceContainer&'");
 
    RunAsRtcComponent<BL>(args, std::make_unique<BL, std::string const&, ServiceContainer&>);
}
 
}  // namespace rtctk::componentFramework
 
#ifndef RTCTK_NOMAIN
namespace rtctk::componentFramework {
 
int Main(int argc, char* argv[]) {
    LogInitializer initializer;
 
    try {
        Args args{argc, argv};
 
        auto name = args.GetComponentName();
        auto log_props_file = args.GetLogPropsFile();
        auto debug_mode = args.GetDebugMode();
 
        if (log_props_file.has_value()) {
            auto props_file = log_props_file.value().path().to_string();
            LogConfigure(name, props_file);
        } else {
            auto level = debug_mode ? log4cplus::DEBUG_LOG_LEVEL : log4cplus::INFO_LOG_LEVEL;
            LogConfigure(name, level);
        }
 
        // Call user implementation of RtcComponentMain
        ::RtcComponentMain(args);
 
        return EXIT_SUCCESS;
 
    } catch (Args::HelpOnly const& e) {
        std::cout << e.what() << std::endl;
        return EXIT_SUCCESS;
    } catch (Args::ArgNotSet const& e) {
        std::cerr << e.what() << std::endl;
    } catch (boost::program_options::error const& e) {
        std::cerr << "Command line arguments parsing ERROR: " << e.what();
        std::cerr << ", use -h for help." << std::endl;
    } catch (std::exception const& e) {
        LOG4CPLUS_FATAL(GetLogger("rtctk"), NestedExceptionPrinter(e));
    } catch (...) {
        LOG4CPLUS_FATAL(GetLogger("rtctk"), NestedExceptionPrinter(std::current_exception()));
    }
    return EXIT_FAILURE;
}
 
}  // namespace rtctk::componentFramework
 
int main(int argc, char* argv[]) {
    try {
        return rtctk::componentFramework::Main(argc, argv);
    } catch (...) {
        // Note: Use minimal formatting to avoid further exception leaks.
        // This handler is only here to avoid std::terminate due to exception-leaks.
        constexpr std::string_view msg =
            "Caught exception leaked from rtctk::componentFramework::Main\n";
        std::cerr.write(msg.data(), msg.size());
    }
}
#endif  // RTCTK_NOMAIN
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENTMAIN_HPP