1 #include "conditions.hpp"
2 
3 #include "sdbusplus.hpp"
4 #include "types.hpp"
5 
6 #include <nlohmann/json.hpp>
7 #include <phosphor-logging/log.hpp>
8 
9 #include <algorithm>
10 
11 namespace phosphor
12 {
13 namespace fan
14 {
15 namespace monitor
16 {
17 namespace condition
18 {
19 
20 using json = nlohmann::json;
21 using namespace phosphor::logging;
22 
23 Condition propertiesMatch(std::vector<PropertyState>&& propStates)
24 {
25     return [pStates = std::move(propStates)](sdbusplus::bus_t& bus) {
26         return std::all_of(pStates.begin(), pStates.end(),
27                            [&bus](const auto& p) {
28             return util::SDBusPlus::getPropertyVariant<PropertyValue>(
29                        bus, std::get<propObj>(p.first),
30                        std::get<propIface>(p.first),
31                        std::get<propName>(p.first)) == p.second;
32         });
33     };
34 }
35 
36 Condition getPropertiesMatch(const json& condParams)
37 {
38     if (!condParams.contains("properties"))
39     {
40         // Log error on missing required parameter
41         log<level::ERR>(
42             "Missing fan monitor condition properties",
43             entry("NAME=%s", condParams["name"].get<std::string>().c_str()));
44         throw std::runtime_error("Missing fan monitor condition properties");
45     }
46     std::vector<PropertyState> propStates;
47     for (auto& param : condParams["properties"])
48     {
49         if (!param.contains("object") || !param.contains("interface") ||
50             !param.contains("property"))
51         {
52             // Log error on missing required parameters
53             log<level::ERR>("Missing propertiesMatch condition parameters",
54                             entry("REQUIRED_PARAMETERS=%s",
55                                   "{object, interface, property}"));
56             throw std::runtime_error(
57                 "Missing propertiesMatch condition parameters");
58         }
59 
60         auto propAttrs = param["property"];
61         if (!propAttrs.contains("name") || !propAttrs.contains("value"))
62         {
63             // Log error on missing required parameters
64             log<level::ERR>(
65                 "Missing propertiesMatch condition property attributes",
66                 entry("REQUIRED_ATTRIBUTES=%s", "{name, value}"));
67             throw std::runtime_error(
68                 "Missing propertiesMatch condition property attributes");
69         }
70 
71         std::string type = "";
72         if (propAttrs.contains("type"))
73         {
74             type = propAttrs["type"].get<std::string>();
75         }
76 
77         // Add property for propertiesMatch condition
78         propStates.emplace_back(PropertyState(
79             {param["object"].get<std::string>(),
80              param["interface"].get<std::string>(),
81              propAttrs["name"].get<std::string>()},
82             JsonTypeHandler::getPropValue(propAttrs["value"], type)));
83     }
84 
85     return make_condition(condition::propertiesMatch(std::move(propStates)));
86 }
87 
88 } // namespace condition
89 } // namespace monitor
90 } // namespace fan
91 } // namespace phosphor
92