rtcSupervisor.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_RTCSUPERVISOR_RTCSUPERVISOR_HPP
#define RTCTK_RTCSUPERVISOR_RTCSUPERVISOR_HPP
 
#include <rtctk/componentFramework/alertServiceIf.hpp>
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/persistentRepoIf.hpp>
#include <rtctk/componentFramework/populateConfig.hpp>
#include <rtctk/componentFramework/runnable.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
#include <rtctk/componentFramework/serviceDiscovery.hpp>
#include <rtctk/componentFramework/stateSubscriber.hpp>
 
#include <rtctk/rtcSupervisor/alertAggregator.hpp>
#include <rtctk/rtcSupervisor/rtcMonitor.hpp>
#include <rtctk/rtcSupervisor/rtcObjectController.hpp>
#include <rtctk/rtcSupervisor/statusEstimator.hpp>
#include <rtctk/rtcSupervisor/statusPublisher.hpp>
#include <rtctk/rtcSupervisor/supervisory.hpp>
 
#include <map>
#include <mutex>
#include <string>
 
namespace rtctk::rtcSupervisor {
 
using namespace rtctk::componentFramework;
 
using Super = Supervisory<RtcComponent>;
 
class RtcSupervisor : public Super::BizLogicIf {
public:
    using ComponentType = Super;
 
    RtcSupervisor(const std::string& comp_name, ServiceContainer& services);
    virtual ~RtcSupervisor();
 
    void ActivityStarting(StopToken st) override;
    void ActivityInitialising(StopToken st) override;
    void ActivityEnabling(StopToken st) override;
    void ActivityDisabling(StopToken st) override;
 
    void ActivityUpdating(StopToken st, const JsonPayload& args) override;
    bool GuardUpdatingAllowed(const JsonPayload& args) override;
 
    void ActionClearAlerts() override;
 
    void ActivityRecovering(StopToken st) override;
 
    std::string ActionGetStatus() override;
 
    JsonPayload ActionGetAvailableModes() override;
    JsonPayload ActionGetActiveModes() override;
    JsonPayload ActionGetDeferredModes() override;
    void ActionSetDeferredModes(const JsonPayload& args) override;
    void ActivitySettingModes(StopToken st, const JsonPayload& args) override;
    bool GuardSettingModesAllowed(const JsonPayload& args) override;
 
    void ActivityWritingBack(StopToken st, const JsonPayload& args) override;
    bool GuardWritingBackAllowed(const JsonPayload& args) override;
 
protected:
    std::vector<std::unique_ptr<RtcObjectIf>> MakeRtcObjects();
 
    std::vector<elt::mal::Uri> GetPubSubUris();
 
    void MonitorCycle() noexcept;
 
    void OnStateEventReceived(const taiclock::TaiClock::time_point,
                              const std::string& name,
                              const std::string& state) noexcept;
 
    void SetStatus(const std::string& status);
 
    std::string GetStatus();
 
    void LoadStaticConfig();
 
    void LoadDynamicConfig();
 
    log4cplus::Logger& m_logger;
 
    // component identity
    const std::string m_name;
 
    // access to services
    PersistentRepoIf& m_psr;
    RuntimeRepoIf& m_rtr;
    OldbIf& m_oldb;
    ComponentMetricsIf& m_metrics;
    AlertServiceIf& m_alerts;
    ServiceDiscovery& m_service_discovery;
 
    StatusPublisher m_status_publisher;
    PopulateConfig m_popcfg;
 
    // alert is set if periodic pinging of components fails
    AlertSource m_heartbeat_alert;
 
    // alert is set if commanding the supervisor fails
    AlertSource m_command_alert;
 
    // alert is set if OLDB cannot be accessed
    AlertSource m_oldb_alert;
 
    // Object Config constructed from list of deployed objects.
    std::vector<std::unique_ptr<RtcObjectIf>> m_objects;
    std::unique_ptr<RtcObjectController> m_object_controller;
 
    // DataPointPaths for confiugration datapoints
    DataPointPath m_dp_path_init_alone;
    DataPointPath m_dp_path_enable_alone;
    DataPointPath m_dp_path_disable_alone;
    DataPointPath m_dp_path_update_alone;
 
    // DataPointPaths for monitoring datapoints
    DataPointPath m_dp_path_status;
 
    // Local state variables
    bool m_init_alone;
    bool m_enable_alone;
    bool m_disable_alone;
    bool m_update_alone;
 
    // mutex to control access on m_status, m_error and m_who_in_error from different threads
    std::mutex m_status_mutex;
 
    // currently evaluated global status
    std::string m_status;
 
    // stores deferred modes that may be set via command before initialising
    std::map<std::string, std::string> m_deferred_modes;
 
    // these access class variables, therefore they must be destroyed first, otherwise coredump!!
 
    // used for system status estimation
    std::unique_ptr<StatusEstimator> m_status_estimator;
 
    // used for periodic component monitoring
    std::unique_ptr<RtcMonitor> m_monitor_thread;
 
    // used to get state-changed notifications from all components
    std::unique_ptr<StateSubscriber> m_state_subscriber;
 
    // used for system alert aggregation
    std::unique_ptr<AlertAggregator> m_alert_aggregator;
};
 
}  // namespace rtctk::rtcSupervisor
 
#endif  // RTCTK_RTCSUPERVISOR_RTCSUPERVISOR_HPP