eventDefinitions.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_EVENTDEFINITIONS_HPP
#define RTCTK_COMPONENTFRAMEWORK_EVENTDEFINITIONS_HPP
 
#include <rtctk/componentFramework/jsonPayload.hpp>
 
#include <boost/core/demangle.hpp>
#include <chrono>
 
namespace rtctk::componentFramework {
 
template <typename T>
std::string PrettyTypeName() {
    return boost::core::demangle((typeid(T).name()));
}
 
inline uint64_t GetTimestamp() {
    using namespace std::chrono;
    return duration_cast<nanoseconds>(system_clock::now().time_since_epoch()).count();
}
 
 
struct AbstractEvent {
    AbstractEvent() = delete;
 
    AbstractEvent(JsonPayload const& payload) : origin(payload["origin"]), time(payload["time"]) {
    }
 
    AbstractEvent(std::string const& origin) : origin(origin), time(GetTimestamp()) {
    }
 
    JsonPayload ToJson() const {
        JsonPayload payload;
        payload["type"] = std::vector<std::string>();
        payload["origin"] = origin;
        payload["time"] = time;
        return payload;
    }
 
    std::string origin;  // which component performed computation
    uint64_t time;       // when was computation performed
};
 
 
struct ComputationEvent : AbstractEvent {
    inline static const std::string TOPIC_NAME = "computation_topic";
 
    ComputationEvent(std::string const& origin, std::string const& item, std::string const& state)
        : AbstractEvent(origin), item(item), state(state) {
    }
 
    ComputationEvent(std::string const& origin, std::string const& item)
        : ComputationEvent(origin, item, "finished") {
    }
 
    ComputationEvent(JsonPayload const& payload)
        : AbstractEvent(payload), item(payload["item"]), state(payload["state"]) {
    }
 
    JsonPayload ToJson() const {
        auto payload = AbstractEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<ComputationEvent>());
        payload["item"] = item;
        payload["state"] = state;
        return payload;
    }
 
    std::string item;   // what was computed
    std::string state;  // was computaton started, finished, failed
};
 
struct ComputationStartedEvent : ComputationEvent {
    ComputationStartedEvent(std::string const& origin, std::string const& item)
        : ComputationEvent(origin, item, "started") {
    }
 
    ComputationStartedEvent(JsonPayload const& payload) : ComputationEvent(payload) {
    }
 
    JsonPayload ToJson() const {
        auto payload = ComputationEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<ComputationStartedEvent>());
        return payload;
    }
};
 
struct ComputationFinishedEvent : ComputationEvent {
    ComputationFinishedEvent(std::string const& origin, std::string const& item)
        : ComputationEvent(origin, item, "finished") {
    }
 
    ComputationFinishedEvent(std::string const& origin,
                             std::string const& item,
                             JsonPayload const& result)
        : ComputationEvent(origin, item, "finished"), result(result) {
    }
 
    ComputationFinishedEvent(JsonPayload const& payload)
        : ComputationEvent(payload), result(payload["result"]) {
    }
 
    JsonPayload ToJson() const {
        auto payload = ComputationEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<ComputationFinishedEvent>());
        payload["result"] = result;
        return payload;
    }
 
    JsonPayload result;
};
 
 
struct ConfigurationEvent : AbstractEvent {
    inline static const std::string TOPIC_NAME = "configuration_topic";
 
    ConfigurationEvent(std::string const& origin, std::string const& item, std::string const& state)
        : AbstractEvent(origin), items({item}), state(state) {
    }
 
    ConfigurationEvent(std::string const& origin,
                       std::vector<std::string> const& items,
                       std::string const& state)
        : AbstractEvent(origin), items(items), state(state) {
    }
 
    ConfigurationEvent(JsonPayload const& payload)
        : AbstractEvent(payload), items(payload["items"]), state(payload["state"]) {
    }
 
    JsonPayload ToJson() const {
        auto payload = AbstractEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<ConfigurationEvent>());
        payload["items"] = items;
        payload["state"] = state;
        return payload;
    }
 
    std::vector<std::string> items;  // what was configured
    std::string state;               // was configuration scheduled, started, finished, failed
};
 
struct ConfigurationUpdatedEvent : ConfigurationEvent {
    ConfigurationUpdatedEvent(std::string const& origin, std::string const& item)
        : ConfigurationEvent(origin, item, "updated") {
    }
 
    ConfigurationUpdatedEvent(std::string const& origin, std::vector<std::string> const& items)
        : ConfigurationEvent(origin, items, "updated") {
    }
 
    ConfigurationUpdatedEvent(JsonPayload const& payload) : ConfigurationEvent(payload) {
    }
 
    JsonPayload ToJson() const {
        auto payload = ConfigurationEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<ConfigurationUpdatedEvent>());
        return payload;
    }
};
 
struct ConfigurationRetrievedEvent : ConfigurationEvent {
    ConfigurationRetrievedEvent(std::string const& origin, std::string const& item)
        : ConfigurationEvent(origin, item, "retrieved") {
    }
 
    ConfigurationRetrievedEvent(std::string const& origin, std::vector<std::string> const& items)
        : ConfigurationEvent(origin, items, "retrieved") {
    }
 
    ConfigurationRetrievedEvent(JsonPayload const& payload) : ConfigurationEvent(payload) {
    }
 
    JsonPayload ToJson() const {
        auto payload = ConfigurationEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<ConfigurationRetrievedEvent>());
        return payload;
    }
};
 
struct HrtcConfigurationScheduledEvent : ConfigurationEvent {
    HrtcConfigurationScheduledEvent(std::string const& origin,
                                    std::string const& item,
                                    std::string const& hrtc_origin,
                                    uint64_t hrtc_timestamp,
                                    uint64_t hrtc_sample_id)
        : ConfigurationEvent(origin, item, "scheduled")
        , hrtc_origin(hrtc_origin)
        , hrtc_timestamp(hrtc_timestamp)
        , hrtc_sample_id(hrtc_sample_id) {
    }
 
    HrtcConfigurationScheduledEvent(JsonPayload const& payload)
        : ConfigurationEvent(payload)
        , hrtc_origin(payload["hrtc_origin"])
        , hrtc_timestamp(payload["hrtc_timestamp"])
        , hrtc_sample_id(payload["hrtc_sample_id"]) {
    }
 
    JsonPayload ToJson() const {
        auto payload = ConfigurationEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<HrtcConfigurationScheduledEvent>());
        payload["hrtc_origin"] = hrtc_origin;
        payload["hrtc_timestamp"] = hrtc_timestamp;
        payload["hrtc_sample_id"] = hrtc_sample_id;
        return payload;
    }
 
    std::string hrtc_origin;
    uint64_t hrtc_timestamp;
    uint64_t hrtc_sample_id;
};
 
struct HrtcConfigurationAppliedEvent : ConfigurationEvent {
    HrtcConfigurationAppliedEvent(std::string const& origin,
                                  std::string const& item,
                                  std::string const& hrtc_origin,
                                  uint64_t hrtc_timestamp,
                                  uint64_t hrtc_sample_id)
        : ConfigurationEvent(origin, item, "applied")
        , hrtc_origin(hrtc_origin)
        , hrtc_timestamp(hrtc_timestamp)
        , hrtc_sample_id(hrtc_sample_id) {
    }
 
    HrtcConfigurationAppliedEvent(JsonPayload const& payload)
        : ConfigurationEvent(payload)
        , hrtc_origin(payload["hrtc_origin"])
        , hrtc_timestamp(payload["hrtc_timestamp"])
        , hrtc_sample_id(payload["hrtc_sample_id"]) {
    }
 
    JsonPayload ToJson() const {
        auto payload = ConfigurationEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<HrtcConfigurationAppliedEvent>());
        payload["hrtc_origin"] = hrtc_origin;
        payload["hrtc_timestamp"] = hrtc_timestamp;
        payload["hrtc_sample_id"] = hrtc_sample_id;
        return payload;
    }
 
    std::string hrtc_origin;
    uint64_t hrtc_timestamp;
    uint64_t hrtc_sample_id;
};
 
 
struct CoordinationEvent : AbstractEvent {
    inline static const std::string TOPIC_NAME = "coordination_topic";
 
    CoordinationEvent(std::string const& origin) : AbstractEvent(origin) {
    }
 
    CoordinationEvent(JsonPayload const& payload) : AbstractEvent(payload) {
    }
 
    JsonPayload ToJson() const {
        auto payload = AbstractEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<CoordinationEvent>());
        return payload;
    }
};
 
struct StateChangedEvent : CoordinationEvent {
    StateChangedEvent(std::string const& origin,
                      std::string const& entity,
                      std::string const& state)
        : CoordinationEvent(origin), entity(entity), state(state) {
    }
 
    StateChangedEvent(std::string const& origin, std::string const& state)
        : StateChangedEvent(origin, origin, state) {
    }
 
    StateChangedEvent(JsonPayload const& payload)
        : CoordinationEvent(payload), entity(payload["entity"]), state(payload["state"]) {
    }
 
    JsonPayload ToJson() const {
        auto payload = CoordinationEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<StateChangedEvent>());
        payload["state"] = state;
        payload["entity"] = entity;
        return payload;
    }
 
    std::string entity;
    std::string state;
};
 
struct HrtcStateChangedEvent : StateChangedEvent {
    HrtcStateChangedEvent(std::string const& origin,
                          std::string const& entity,
                          std::string const& state,
                          uint64_t hrtc_timestamp,
                          uint64_t hrtc_sample_id)
        : StateChangedEvent(origin, entity, state)
        , hrtc_timestamp(hrtc_timestamp)
        , hrtc_sample_id(hrtc_sample_id) {
    }
 
    HrtcStateChangedEvent(JsonPayload const& payload)
        : StateChangedEvent(payload)
        , hrtc_timestamp(payload["hrtc_timestamp"])
        , hrtc_sample_id(payload["hrtc_sample_id"]) {
    }
 
    JsonPayload ToJson() const {
        auto payload = StateChangedEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<HrtcStateChangedEvent>());
        payload["hrtc_timestamp"] = hrtc_timestamp;
        payload["hrtc_sample_id"] = hrtc_sample_id;
        return payload;
    }
 
    uint64_t hrtc_timestamp;
    uint64_t hrtc_sample_id;
};
 
struct AlertStatusEvent : AbstractEvent {
    inline static const std::string TOPIC_NAME = "alert_status_topic";
 
    struct Alert {
        std::string origin;
 
        std::string id;
 
        std::string description;
 
        std::uint64_t since;
    };
 
    AlertStatusEvent(bool st, std::vector<Alert> ac, std::string const& origin)
        : AbstractEvent(origin), status(st), active_alerts(std::move(ac)) {
    }
 
    AlertStatusEvent(JsonPayload const& json) : AbstractEvent(json) {
        json["status"].get_to(status);
        for (auto&& active : json["active_alerts"]) {
            Alert alert;
            active["id"].get_to(alert.id);
            active["description"].get_to(alert.description);
            active["origin"].get_to(alert.origin);
            active["since"].get_to(alert.since);
            active_alerts.push_back(alert);
        }
    }
 
    JsonPayload ToJson() const {
        auto payload = AbstractEvent::ToJson();
        payload["type"].push_back(PrettyTypeName<AlertStatusEvent>());
        payload["status"] = status;
        JsonPayload json_active;
        for (auto&& alert : active_alerts) {
            json_active.push_back(JsonPayload{{"origin", alert.origin},
                                              {"id", alert.id},
                                              {"description", alert.description},
                                              {"since", alert.since}});
        }
        payload["active_alerts"] = std::move(json_active);
        return payload;
    }
 
    bool status;
    std::vector<Alert> active_alerts;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_EVENTDEFINITIONS_HPP