alertService.hpp

Go to the documentation of this file.

#ifndef RTCTK_COMPONENTFRAMEWORK_ALERTSERVICE_HPP
#define RTCTK_COMPONENTFRAMEWORK_ALERTSERVICE_HPP
 
#include <rtctk/componentFramework/alertServiceIf.hpp>
#include <rtctk/componentFramework/eventDefinitions.hpp>
#include <rtctk/componentFramework/eventServiceIf.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/telegrafAdapter.hpp>
 
#include <taiclock/taiClock.hpp>
 
#include <string>
#include <vector>
 
namespace rtctk::componentFramework {

class AlertUnknownException : public RtctkException {
public:
    explicit AlertUnknownException(const std::string& id);
};
 
struct AlertInfo {
    using TimePoint = taiclock::TaiClock::time_point;
 
    AlertInfo(bool state, TimePoint since, const std::string& id, const std::string& text);
 
    bool state;
    TimePoint since;
    std::string id;
    std::string text;
};
 
struct AlertObserverIf {
    virtual ~AlertObserverIf() = default;
    virtual void
    Publish(const AlertInfo& reduced, const std::vector<AlertInfo>& alerts) noexcept = 0;
};

class AlertOldbPublisher : public AlertObserverIf {
public:
    AlertOldbPublisher(const std::string& name, OldbIf& oldb);
    void Publish(const AlertInfo& reduced, const std::vector<AlertInfo>& alerts) noexcept override;
 
private:
    std::string m_name;
    OldbIf& m_oldb;
    log4cplus::Logger m_logger;
};

class AlertLogger : public AlertObserverIf {
public:
    AlertLogger();
    void Publish(const AlertInfo& reduced, const std::vector<AlertInfo>& alerts) noexcept override;
 
private:
    log4cplus::Logger m_logger;
};

class AlertEventPublisher : public AlertObserverIf {
public:
    AlertEventPublisher(const std::string& name, EventServiceIf& ev);
    void Publish(const AlertInfo& reduced, const std::vector<AlertInfo>& alerts) noexcept override;
 
private:
    std::string m_name;
    EventServiceIf& m_svc;
    std::unique_ptr<EventPublisherIf> m_publisher;
    log4cplus::Logger m_logger;
};

class AlertTelegrafPublisher : public AlertObserverIf {
public:
    AlertTelegrafPublisher(const std::string& name, TelegrafAdapter& telegraf_adapter);
    void Publish(const AlertInfo& reduced, const std::vector<AlertInfo>& alerts) noexcept override;
 
private:
    std::string m_name;
    TelegrafAdapter& m_telegraf_adapter;
    log4cplus::Logger m_logger;
};
 
class AlertStatus {
public:
    AlertStatus();
    ~AlertStatus();
 
    void AddObserver(std::unique_ptr<AlertObserverIf> o);
 
    void AddAlert(const std::string& id, const std::string& text);
 
    void SetAlert(const std::string& id, bool state = true);
 
    void ClearAlerts();
 
    AlertInfo GetInfo(const std::string& id);
 
private:
    std::recursive_mutex m_mtx;
    AlertInfo m_reduced;
    std::vector<AlertInfo> m_alerts;
    size_t m_last_size = 0;
    std::vector<std::unique_ptr<AlertObserverIf>> m_observers;
};
 
class AlertService : public AlertServiceIf {
public:
    void AddObserver(std::unique_ptr<AlertObserverIf> o) {
        m_status.AddObserver(std::move(o));
    }
 
    AlertSource MakeAlertSource(const std::string& id, const std::string& text) override {
        return {m_status, id, text};
    };
 
    bool GetStatus() override {
        return m_status.GetInfo("").state;
    }
 
    void ClearAll() override {
        m_status.ClearAlerts();
    }
 
private:
    AlertStatus m_status;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_ALERTSERVICE_HPP