summaryrefslogtreecommitdiffstats
path: root/sensordatahandler.hpp
blob: f75c37727b98ca2a82654bb329836cc38d2be436 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
#include "types.hpp"
#include "host-ipmid/ipmid-api.h"

namespace ipmi
{
namespace sensor
{

using Assertion = uint16_t;
using Deassertion = uint16_t;
using AssertionSet = std::pair<Assertion, Deassertion>;

using Service = std::string;
using Path = std::string;
using Interface = std::string;

using ServicePath = std::pair<Path, Service>;

using Interfaces = std::vector<Interface>;

using MapperResponseType = std::map<Path, std::map<Service, Interfaces>>;

/** @brief get the D-Bus service and service path
 *  @param[in] bus - The Dbus bus object
 *  @param[in] interface - interface to the service
 *  @param[in] path - interested path in the list of objects
 *  @return pair of service path and service
 */
ServicePath getServiceAndPath(sdbusplus::bus::bus& bus,
                              const std::string& interface,
                              const std::string& path = std::string());

/** @brief Make assertion set from input data
 *  @param[in] cmdData - Input sensor data
 *  @return pair of assertion and deassertion set
 */
AssertionSet getAssertionSet(const SetSensorReadingReq& cmdData);

/** @brief send the message to DBus
 *  @param[in] msg - message to send
 *  @return failure status in IPMI error code
 */
ipmi_ret_t updateToDbus(IpmiUpdateData& msg);

namespace set
{

/** @brief Make a DBus message for a Dbus call
 *  @param[in] updateInterface - Interface name
 *  @param[in] sensorPath - Path of the sensor
 *  @param[in] command - command to be executed
 *  @param[in] sensorInterface - DBus interface of sensor
 *  @return a dbus message
 */
IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
                           const std::string& sensorPath,
                           const std::string& command,
                           const std::string& sensorInterface);

/** @brief Create a message for IPMI assertion
 *  @param[in] msg - Message to add the values
 *  @param[in] interface - sensor interface
 *  @param[in] sensorPath - Path of the sensor
 *  @param[in] cmdData - input sensor data
 *  @return a IPMI error code
 */
ipmi_ret_t appendAssertion(IpmiUpdateData& msg,
                           const DbusInterfaceMap& interfaceMap,
                           const std::string& sensorPath,
                           const SetSensorReadingReq& cmdData);

/** @brief Create a message for discrete signal
 *  @param[in] msg - Message to add the values
 *  @param[in] interface - sensor interface
 *  @param[in] data - input discrete sensor data
 *  @return a IPMI error code
 */
ipmi_ret_t appendDiscreteSignalData(IpmiUpdateData& msg,
                                    const DbusInterfaceMap& interfaceMap,
                                    uint8_t data);

/** @brief Create a message for reading data
 *  @param[in] msg - Message to add the values
 *  @param[in] interface - sensor interface
 *  @param[in] data - input sensor data
 *  @return a IPMI error code
 */
ipmi_ret_t appendReadingData(IpmiUpdateData& msg,
                             const DbusInterfaceMap& interfaceMap,
                             const Value& data);

}//namespace set

namespace notify
{

/** @brief Make a DBus message for a Dbus call
 *  @param[in] updateInterface - Interface name
 *  @param[in] sensorPath - Path of the sensor
 *  @param[in] command - command to be executed
 *  @param[in] sensorInterface - DBus interface of sensor
 *  @return a dbus message
 */
IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
                           const std::string& sensorPath,
                           const std::string& command,
                           const std::string& sensorInterface);

/** @brief Create a message for IPMI discrete signal
 *  @param[in] msg - Message to add the values
 *  @param[in] interfaceMap - sensor interface
 *  @param[in] sensorPath - Path of the sensor
 *  @param[in] cmdData - input sensor data
 *  @return a IPMI error code
 */
inline ipmi_ret_t appendDiscreteSignalData(IpmiUpdateData& msg,
        const DbusInterfaceMap& interfaceMap,
        uint8_t data)
{
    return IPMI_CC_OK;
}

/** @brief Create a message for reading data
 *  @param[in] msg - Message to add the values
 *  @param[in] interfaceMap - sensor interface
 *  @param[in] data - input sensor data
 *  @return a IPMI error code
 */
inline ipmi_ret_t appendReadingData(IpmiUpdateData& msg,
                                    const DbusInterfaceMap& interfaceMap,
                                    const Value &data)
{
    return IPMI_CC_OK;
}

/** @brief Create a message for IPMI asserting
 *  @param[in] msg - Message to add the values
 *  @param[in] interfaceMap - sensor interface
 *  @param[in] sensorPath - Path of the sensor
 *  @param[in] cmdData - input sensor data
 *  @return a IPMI error code
 */
ipmi_ret_t appendAssertion(IpmiUpdateData& msg,
                           const DbusInterfaceMap& interfaceMap,
                           const std::string& sensorPath,
                           const SetSensorReadingReq& cmdData);

}//namespace notify
}//namespace sensor
}//namespace ipmi
OpenPOWER on IntegriCloud