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;
EventBase(const PropertyIndex & index)32     EventBase(const PropertyIndex& index) : IndexedCallback(index) {}
33 
34     /** @brief Callback interface implementation. */
operator ()(Context ctx)35     void operator()(Context ctx) override
36     {
37         if (ctx == Context::START)
38         {
39             // No action should be taken
40             // as this call back is being called from
41             // daemon Startup.
42             return;
43         }
44 
45         for (const auto& n : index)
46         {
47             const auto& path = std::get<pathIndex>(n.first);
48             const auto& propertyMeta = std::get<propertyIndex>(n.first);
49             const auto& storage = std::get<storageIndex>(n.second);
50             const auto& value = std::get<valueIndex>(storage.get());
51 
52             if (value.has_value())
53             {
54                 createEvent(path, propertyMeta, value);
55             }
56         }
57     }
58 
59   private:
60     /** @brief Create the event Dbus Object.
61      *  @param[in] path - Dbus Object Path for which the
62      *                    property has changed.
63      *  @param[in] property - Name of the property whose value
64      *                        has been changed.
65      *  @param[in] value - Changed property value.
66      */
67     virtual void createEvent(const std::string& path,
68                              const std::string& property,
69                              const std::any& value) const = 0;
70 };
71 
72 /** @class Event
73  *  @brief C++ type specific logic for the event callback.
74  *
75  *  @tparam T - The C++ type of the property values being traced.
76  */
77 template <typename T>
78 class Event : public EventBase
79 {
80   public:
81     Event() = delete;
82     Event(const Event&) = delete;
83     Event(Event&&) = default;
84     Event& operator=(const Event&) = delete;
85     Event& operator=(Event&&) = default;
86     ~Event() = default;
87 
88     /** @brief Constructor.
89      *  @param[in] eventName - Name of the event.
90      *  @param[in] eventMessage- Event Message.
91      *  @param[in] index - look up index for the properties.
92      */
Event(const std::string & eventName,const std::string & eventMessage,const PropertyIndex & index)93     Event(const std::string& eventName, const std::string& eventMessage,
94           const PropertyIndex& index) :
95         EventBase(index), name(eventName), message(eventMessage)
96     {}
97 
98   private:
99     /** @brief Create the event Dbus Object.
100      *  @param[in] path - Dbus Object Path for which the
101      *                    property has changed.
102      *  @param[in] property - Name of the property whose value
103      *                        has been changed.
104      *  @param[in] value - Changed property value.
105      */
createEvent(const std::string & path,const std::string & property,const std::any & value) const106     void createEvent(const std::string& path, const std::string& property,
107                      const std::any& value) const override
108     {
109         std::stringstream ss{};
110         ss << std::any_cast<T>(value);
111         phosphor::events::getManager().create(name, message, path, property,
112                                               ss.str());
113     }
114 
115     /** @brief Event Name */
116     std::string name;
117 
118     /** @brief Event Message */
119     std::string message;
120 };
121 
122 } // namespace monitoring
123 } // namespace dbus
124 } // namespace phosphor
125