1 #pragma once
2 
3 #include "callback.hpp"
4 #include "event_manager.hpp"
5 
6 #include <sstream>
7 #include <string>
8 
9 namespace phosphor
10 {
11 namespace dbus
12 {
13 namespace monitoring
14 {
15 
16 /** @class EventBase
17  *  @brief Event callback implementation.
18  *
19  *  The event callback creates the event dbus object
20  *  which has event message and metadata as key value pairs
21  *  as specified by the client supplied property index.
22  */
23 class EventBase : public IndexedCallback
24 {
25   public:
26     EventBase() = delete;
27     EventBase(const EventBase&) = delete;
28     EventBase(EventBase&&) = default;
29     EventBase& operator=(const EventBase&) = delete;
30     EventBase& operator=(EventBase&&) = default;
31     virtual ~EventBase() = default;
32     EventBase(const PropertyIndex& index) : IndexedCallback(index)
33     {}
34 
35     /** @brief Callback interface implementation. */
36     void operator()(Context ctx) override
37     {
38         if (ctx == Context::START)
39         {
40             // No action should be taken
41             // as this call back is being called from
42             // daemon Startup.
43             return;
44         }
45 
46         for (const auto& n : index)
47         {
48             const auto& path = std::get<pathIndex>(n.first);
49             const auto& propertyMeta = std::get<propertyIndex>(n.first);
50             const auto& storage = std::get<storageIndex>(n.second);
51             const auto& value = std::get<valueIndex>(storage.get());
52 
53             if (value.has_value())
54             {
55                 createEvent(path, propertyMeta, value);
56             }
57         }
58     }
59 
60   private:
61     /** @brief Create the event Dbus Object.
62      *  @param[in] path - Dbus Object Path for which the
63      *                    property has changed.
64      *  @param[in] property - Name of the property whose value
65      *                        has been changed.
66      *  @param[in] value - Changed property value.
67      */
68     virtual void createEvent(const std::string& path,
69                              const std::string& property,
70                              const std::any& value) const = 0;
71 };
72 
73 /** @class Event
74  *  @brief C++ type specific logic for the event callback.
75  *
76  *  @tparam T - The C++ type of the property values being traced.
77  */
78 template <typename T>
79 class Event : public EventBase
80 {
81   public:
82     Event() = delete;
83     Event(const Event&) = delete;
84     Event(Event&&) = default;
85     Event& operator=(const Event&) = delete;
86     Event& operator=(Event&&) = default;
87     ~Event() = default;
88 
89     /** @brief Constructor.
90      *  @param[in] eventName - Name of the event.
91      *  @param[in] eventMessage- Event Message.
92      *  @param[in] index - look up index for the properties.
93      */
94     Event(const std::string& eventName, const std::string& eventMessage,
95           const PropertyIndex& index) :
96         EventBase(index),
97         name(eventName), message(eventMessage)
98     {}
99 
100   private:
101     /** @brief Create the event Dbus Object.
102      *  @param[in] path - Dbus Object Path for which the
103      *                    property has changed.
104      *  @param[in] property - Name of the property whose value
105      *                        has been changed.
106      *  @param[in] value - Changed property value.
107      */
108     void createEvent(const std::string& path, const std::string& property,
109                      const std::any& value) const override
110     {
111         std::stringstream ss{};
112         ss << std::any_cast<T>(value);
113         phosphor::events::getManager().create(name, message, path, property,
114                                               ss.str());
115     }
116 
117     /** @brief Event Name */
118     std::string name;
119 
120     /** @brief Event Message */
121     std::string message;
122 };
123 
124 } // namespace monitoring
125 } // namespace dbus
126 } // namespace phosphor
127