rtcComponentMain.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENTMAIN_HPP
#define RTCTK_COMPONENTFRAMEWORK_RTCCOMPONENTMAIN_HPP
 
#include <mal/Cii.hpp>
#include <memory>
#include <string>
 
#include <rtctk/componentFramework/detail/rtcComponent.hpp>
 
#include <rtctk/componentFramework/alertService.hpp>
#include <rtctk/componentFramework/commandReplier.hpp>
#include <rtctk/componentFramework/componentMetrics.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
#include <rtctk/componentFramework/serviceDiscovery.hpp>
#include <rtctk/componentFramework/fileServiceRegistryAdapter.hpp>
#include <rtctk/componentFramework/stateMachineEngine.hpp>
#include <rtctk/componentFramework/statePublisher.hpp>
#include <rtctk/componentFramework/malDdsEventService.hpp>
 
#include <rtctk/componentFramework/events.rad.hpp>  // TODO: should not be needed
 
namespace rtctk::componentFramework {
using Args = detail::Args;
}
 
void RtcComponentMain(rtctk::componentFramework::Args const& args);
 
 
namespace rtctk::componentFramework {
 
template <class BL, class BLF>
void RunAsRtcComponent(Args const& args, BLF factory) {
    using namespace std;
 
    auto component_name = args.GetComponentName();
    LOG4CPLUS_INFO(GetLogger(), "RtcComponent '" << component_name << "' started.");
    LOG4CPLUS_DEBUG(GetLogger(), "BusinessLogic is '" << detail::GetTypeName(typeid(BL)) << "'");
 
    ServiceContainer services;
 
    auto svc_disc_endpoint = args.GetServiceDiscEndpoint();
    services.Add<ServiceDiscovery>(
        make_unique<ServiceDiscovery>(std::make_unique<FileServiceRegistryAdapter>(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"),
        GetLogger());
    services.Add<ComponentMetricsIf>(component_metrics);
    ComponentMetricsConfigurator component_metrics_configurator(
        component_metrics,
        rtr_adapter,
        DataPointPath("/") / DataPointPath(component_name) / DataPointPath("dynamic/metrics/default"),
        GetLogger());
 
    // 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>(GetLogger());
    AlertLogger alert_logger(GetLogger(), *alert_service);
    AlertEventPublisher alert_publisher(component_name, *alert_service, *event_service, GetLogger());
    services.Add<AlertServiceIf>(alert_service);
 
    auto rr_endpoint = svc_disc.GetReqRepEndpoint();
    CommandReplier replier(rr_endpoint);
 
    auto ps_endpoint = svc_disc.GetPubSubEndpoint();
    StatePublisher publisher(ps_endpoint, component_name);
 
    StateMachineEngine engine(make_unique<events::Exit>());
 
    engine.RegisterStateChangeHandler([&](string const& 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);
    });
 
    static_assert(is_base_of_v<typename BL::ComponentType::BizLogicIf, BL>,
                  "BusinessLogic must implement BusinessLogicInterface");
 
    static_assert(is_invocable_v<BLF, string const&, ServiceContainer&>,
                  "Factory must be invocable with 'std::string const&' and 'ServiceContainer&'");
 
    static_assert(is_same_v<invoke_result_t<BLF, string const&, ServiceContainer&>, unique_ptr<BL>>,
                  "Factory must return type 'std::unique_ptr<BusinessLogic>'");
 
    // Invoking user factory here -> catch and rethrow RtctkException
    unique_ptr<BL> biz_logic;
    try {
        biz_logic = invoke(factory, component_name, services);
        if (!biz_logic) {
            throw std::runtime_error("BusinessLogic factory did not return a valid object");
        }
    } catch (...) {
        std::throw_with_nested(RtctkException("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(GetLogger(), "RtcComponent '" << component_name << "' terminated.");
}
 
template <class BL>
void RunAsRtcComponent(Args const& args) {
    using namespace std;
 
    static_assert(
        is_constructible_v<BL, string const&, ServiceContainer&>,
        "BusinessLogic must be constructible with 'std::string const&' and 'ServiceContainer&'");
 
    RunAsRtcComponent<BL>(args, make_unique<BL, 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 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);
        }
 
        // Call user implementation of RtcComponentMain
        ::RtcComponentMain(args);
 
        return EXIT_SUCCESS;
 
    } catch (detail::HelpOnly const & e) {
        std::cout << e.what() << std::endl;
        return EXIT_SUCCESS;
    } catch (detail::ArgNotSet const& e) {
        std::cerr << e.what() << std::endl;
    } catch (std::exception const& e) {
        LOG4CPLUS_FATAL(GetLogger(), NestedExceptionPrinter(e));
    } catch (...) {
        LOG4CPLUS_FATAL(GetLogger(), 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