xref: /openbmc/phosphor-fan-presence/monitor/json_parser.cpp (revision 623635c62f229008400e69d6cbfdb84c12610807)
1 /**
2  * Copyright © 2020 IBM Corporation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "json_parser.hpp"
17 
18 #include "conditions.hpp"
19 #include "json_config.hpp"
20 #include "nonzero_speed_trust.hpp"
21 #include "power_interface.hpp"
22 #include "power_off_rule.hpp"
23 #include "tach_sensor.hpp"
24 #include "types.hpp"
25 
26 #include <fmt/format.h>
27 
28 #include <nlohmann/json.hpp>
29 #include <phosphor-logging/log.hpp>
30 
31 #include <algorithm>
32 #include <map>
33 #include <memory>
34 #include <optional>
35 #include <vector>
36 
37 namespace phosphor::fan::monitor
38 {
39 
40 using json = nlohmann::json;
41 using namespace phosphor::logging;
42 
43 namespace tClass
44 {
45 
46 // Get a constructed trust group class for a non-zero speed group
47 CreateGroupFunction
48     getNonZeroSpeed(const std::vector<trust::GroupDefinition>& group)
49 {
50     return [group]() {
51         return std::make_unique<trust::NonzeroSpeed>(std::move(group));
52     };
53 }
54 
55 } // namespace tClass
56 
57 const std::map<std::string, trustHandler> trusts = {
58     {"nonzerospeed", tClass::getNonZeroSpeed}};
59 const std::map<std::string, condHandler> conditions = {
60     {"propertiesmatch", condition::getPropertiesMatch}};
61 const std::map<std::string, size_t> methods = {
62     {"timebased", MethodMode::timebased}, {"count", MethodMode::count}};
63 
64 const std::vector<CreateGroupFunction> getTrustGrps(const json& obj)
65 {
66     std::vector<CreateGroupFunction> grpFuncs;
67 
68     if (obj.contains("sensor_trust_groups"))
69     {
70         for (auto& stg : obj["sensor_trust_groups"])
71         {
72             if (!stg.contains("class") || !stg.contains("group"))
73             {
74                 // Log error on missing required parameters
75                 log<level::ERR>(
76                     "Missing required fan monitor trust group parameters",
77                     entry("REQUIRED_PARAMETERS=%s", "{class, group}"));
78                 throw std::runtime_error(
79                     "Missing required fan trust group parameters");
80             }
81             auto tgClass = stg["class"].get<std::string>();
82             std::vector<trust::GroupDefinition> group;
83             for (auto& member : stg["group"])
84             {
85                 // Construct list of group members
86                 if (!member.contains("name"))
87                 {
88                     // Log error on missing required parameter
89                     log<level::ERR>(
90                         "Missing required fan monitor trust group member name",
91                         entry("CLASS=%s", tgClass.c_str()));
92                     throw std::runtime_error(
93                         "Missing required fan monitor trust group member name");
94                 }
95                 auto in_trust = true;
96                 if (member.contains("in_trust"))
97                 {
98                     in_trust = member["in_trust"].get<bool>();
99                 }
100                 group.emplace_back(trust::GroupDefinition{
101                     member["name"].get<std::string>(), in_trust});
102             }
103             // The class for fan sensor trust groups
104             // (Must have a supported function within the tClass namespace)
105             std::transform(tgClass.begin(), tgClass.end(), tgClass.begin(),
106                            tolower);
107             auto handler = trusts.find(tgClass);
108             if (handler != trusts.end())
109             {
110                 // Call function for trust group class
111                 grpFuncs.emplace_back(handler->second(group));
112             }
113             else
114             {
115                 // Log error on unsupported trust group class
116                 log<level::ERR>("Invalid fan monitor trust group class",
117                                 entry("CLASS=%s", tgClass.c_str()));
118                 throw std::runtime_error(
119                     "Invalid fan monitor trust group class");
120             }
121         }
122     }
123 
124     return grpFuncs;
125 }
126 
127 const std::vector<SensorDefinition> getSensorDefs(const json& sensors)
128 {
129     std::vector<SensorDefinition> sensorDefs;
130 
131     for (const auto& sensor : sensors)
132     {
133         if (!sensor.contains("name") || !sensor.contains("has_target"))
134         {
135             // Log error on missing required parameters
136             log<level::ERR>(
137                 "Missing required fan sensor definition parameters",
138                 entry("REQUIRED_PARAMETERS=%s", "{name, has_target}"));
139             throw std::runtime_error(
140                 "Missing required fan sensor definition parameters");
141         }
142         // Target interface is optional and defaults to
143         // 'xyz.openbmc_project.Control.FanSpeed'
144         std::string targetIntf = "xyz.openbmc_project.Control.FanSpeed";
145         if (sensor.contains("target_interface"))
146         {
147             targetIntf = sensor["target_interface"].get<std::string>();
148         }
149         // Factor is optional and defaults to 1
150         auto factor = 1.0;
151         if (sensor.contains("factor"))
152         {
153             factor = sensor["factor"].get<double>();
154         }
155         // Offset is optional and defaults to 0
156         auto offset = 0;
157         if (sensor.contains("offset"))
158         {
159             offset = sensor["offset"].get<int64_t>();
160         }
161         // Threshold is optional and defaults to 1
162         auto threshold = 1;
163         if (sensor.contains("threshold"))
164         {
165             threshold = sensor["threshold"].get<size_t>();
166         }
167 
168         sensorDefs.emplace_back(std::tuple(
169             sensor["name"].get<std::string>(), sensor["has_target"].get<bool>(),
170             targetIntf, factor, offset, threshold));
171     }
172 
173     return sensorDefs;
174 }
175 
176 const std::vector<FanDefinition> getFanDefs(const json& obj)
177 {
178     std::vector<FanDefinition> fanDefs;
179 
180     for (const auto& fan : obj["fans"])
181     {
182         if (!fan.contains("inventory") || !fan.contains("deviation") ||
183             !fan.contains("sensors"))
184         {
185             // Log error on missing required parameters
186             log<level::ERR>(
187                 "Missing required fan monitor definition parameters",
188                 entry("REQUIRED_PARAMETERS=%s",
189                       "{inventory, deviation, sensors}"));
190             throw std::runtime_error(
191                 "Missing required fan monitor definition parameters");
192         }
193         // Valid deviation range is 0 - 100%
194         auto deviation = fan["deviation"].get<size_t>();
195         if (deviation < 0 || 100 < deviation)
196         {
197             auto msg =
198                 fmt::format(
199                     "Invalid deviation of {} found, must be between 0 and 100",
200                     deviation)
201                     .c_str();
202             log<level::ERR>(msg);
203             throw std::runtime_error(msg);
204         }
205 
206         // Construct the sensor definitions for this fan
207         auto sensorDefs = getSensorDefs(fan["sensors"]);
208 
209         // Functional delay is optional and defaults to 0
210         size_t funcDelay = 0;
211         if (fan.contains("functional_delay"))
212         {
213             funcDelay = fan["functional_delay"].get<size_t>();
214         }
215 
216         // Method is optional and defaults to time based functional
217         // determination
218         size_t method = MethodMode::timebased;
219         size_t countInterval = 1;
220         if (fan.contains("method"))
221         {
222             auto methodConf = fan["method"].get<std::string>();
223             auto methodFunc = methods.find(methodConf);
224             if (methodFunc != methods.end())
225             {
226                 method = methodFunc->second;
227             }
228             else
229             {
230                 // Log error on unsupported method parameter
231                 log<level::ERR>("Invalid fan method");
232                 throw std::runtime_error("Invalid fan method");
233             }
234 
235             // Read the count interval value used with the count method.
236             if (method == MethodMode::count)
237             {
238                 if (fan.contains("count_interval"))
239                 {
240                     countInterval = fan["count_interval"].get<size_t>();
241                 }
242             }
243         }
244 
245         // Timeout defaults to 0
246         size_t timeout = 0;
247         if (method == MethodMode::timebased)
248         {
249             if (!fan.contains("allowed_out_of_range_time"))
250             {
251                 // Log error on missing required parameter
252                 log<level::ERR>(
253                     "Missing required fan monitor definition parameters",
254                     entry("REQUIRED_PARAMETER=%s",
255                           "{allowed_out_of_range_time}"));
256                 throw std::runtime_error(
257                     "Missing required fan monitor definition parameters");
258             }
259             else
260             {
261                 timeout = fan["allowed_out_of_range_time"].get<size_t>();
262             }
263         }
264 
265         // Monitor start delay is optional and defaults to 0
266         size_t monitorDelay = 0;
267         if (fan.contains("monitor_start_delay"))
268         {
269             monitorDelay = fan["monitor_start_delay"].get<size_t>();
270         }
271 
272         // num_sensors_nonfunc_for_fan_nonfunc is optional and defaults
273         // to zero if not present, meaning the code will not set the
274         // parent fan to nonfunctional based on sensors.
275         size_t nonfuncSensorsCount = 0;
276         if (fan.contains("num_sensors_nonfunc_for_fan_nonfunc"))
277         {
278             nonfuncSensorsCount =
279                 fan["num_sensors_nonfunc_for_fan_nonfunc"].get<size_t>();
280         }
281 
282         // nonfunc_rotor_error_delay is optional, though it will
283         // default to zero if 'fault_handling' is present.
284         std::optional<size_t> nonfuncRotorErrorDelay;
285         if (fan.contains("nonfunc_rotor_error_delay"))
286         {
287             nonfuncRotorErrorDelay =
288                 fan["nonfunc_rotor_error_delay"].get<size_t>();
289         }
290         else if (obj.contains("fault_handling"))
291         {
292             nonfuncRotorErrorDelay = 0;
293         }
294 
295         // fan_missing_error_delay is optional.
296         std::optional<size_t> fanMissingErrorDelay;
297         if (fan.contains("fan_missing_error_delay"))
298         {
299             fanMissingErrorDelay =
300                 fan.at("fan_missing_error_delay").get<size_t>();
301         }
302 
303         // Handle optional conditions
304         auto cond = std::optional<Condition>();
305         if (fan.contains("condition"))
306         {
307             if (!fan["condition"].contains("name"))
308             {
309                 // Log error on missing required parameter
310                 log<level::ERR>(
311                     "Missing required fan monitor condition parameter",
312                     entry("REQUIRED_PARAMETER=%s", "{name}"));
313                 throw std::runtime_error(
314                     "Missing required fan monitor condition parameter");
315             }
316             auto name = fan["condition"]["name"].get<std::string>();
317             // The function for fan monitoring condition
318             // (Must have a supported function within the condition namespace)
319             std::transform(name.begin(), name.end(), name.begin(), tolower);
320             auto handler = conditions.find(name);
321             if (handler != conditions.end())
322             {
323                 cond = handler->second(fan["condition"]);
324             }
325             else
326             {
327                 log<level::INFO>(
328                     "No handler found for configured condition",
329                     entry("CONDITION_NAME=%s", name.c_str()),
330                     entry("JSON_DUMP=%s", fan["condition"].dump().c_str()));
331             }
332         }
333 
334         fanDefs.emplace_back(std::tuple(
335             fan["inventory"].get<std::string>(), method, funcDelay, timeout,
336             deviation, nonfuncSensorsCount, monitorDelay, countInterval,
337             nonfuncRotorErrorDelay, fanMissingErrorDelay, sensorDefs, cond));
338     }
339 
340     return fanDefs;
341 }
342 
343 PowerRuleState getPowerOffPowerRuleState(const json& powerOffConfig)
344 {
345     // The state is optional and defaults to runtime
346     PowerRuleState ruleState{PowerRuleState::runtime};
347 
348     if (powerOffConfig.contains("state"))
349     {
350         auto state = powerOffConfig.at("state").get<std::string>();
351         if (state == "at_pgood")
352         {
353             ruleState = PowerRuleState::atPgood;
354         }
355         else if (state != "runtime")
356         {
357             auto msg = fmt::format("Invalid power off state entry {}", state);
358             log<level::ERR>(msg.c_str());
359             throw std::runtime_error(msg.c_str());
360         }
361     }
362 
363     return ruleState;
364 }
365 
366 std::unique_ptr<PowerOffCause> getPowerOffCause(const json& powerOffConfig)
367 {
368     std::unique_ptr<PowerOffCause> cause;
369 
370     if (!powerOffConfig.contains("count") || !powerOffConfig.contains("cause"))
371     {
372         const auto msg =
373             "Missing 'count' or 'cause' entries in power off config";
374         log<level::ERR>(msg);
375         throw std::runtime_error(msg);
376     }
377 
378     auto count = powerOffConfig.at("count").get<size_t>();
379     auto powerOffCause = powerOffConfig.at("cause").get<std::string>();
380 
381     const std::map<std::string, std::function<std::unique_ptr<PowerOffCause>()>>
382         causes{
383             {"missing_fan_frus",
384              [count]() { return std::make_unique<MissingFanFRUCause>(count); }},
385             {"nonfunc_fan_rotors", [count]() {
386                  return std::make_unique<NonfuncFanRotorCause>(count);
387              }}};
388 
389     auto it = causes.find(powerOffCause);
390     if (it != causes.end())
391     {
392         cause = it->second();
393     }
394     else
395     {
396         auto msg =
397             fmt::format("Invalid power off cause {} in power off config JSON",
398                         powerOffCause);
399         log<level::ERR>(msg.c_str());
400         throw std::runtime_error(msg.c_str());
401     }
402 
403     return cause;
404 }
405 
406 std::unique_ptr<PowerOffAction>
407     getPowerOffAction(const json& powerOffConfig,
408                       std::shared_ptr<PowerInterfaceBase>& powerInterface,
409                       PowerOffAction::PrePowerOffFunc& func)
410 {
411     std::unique_ptr<PowerOffAction> action;
412     if (!powerOffConfig.contains("type"))
413     {
414         const auto msg = "Missing 'type' entry in power off config";
415         log<level::ERR>(msg);
416         throw std::runtime_error(msg);
417     }
418 
419     auto type = powerOffConfig.at("type").get<std::string>();
420 
421     if (((type == "hard") || (type == "soft")) &&
422         !powerOffConfig.contains("delay"))
423     {
424         const auto msg = "Missing 'delay' entry in power off config";
425         log<level::ERR>(msg);
426         throw std::runtime_error(msg);
427     }
428     else if ((type == "epow") &&
429              (!powerOffConfig.contains("service_mode_delay") ||
430               !powerOffConfig.contains("meltdown_delay")))
431     {
432         const auto msg = "Missing 'service_mode_delay' or 'meltdown_delay' "
433                          "entry in power off config";
434         log<level::ERR>(msg);
435         throw std::runtime_error(msg);
436     }
437 
438     if (type == "hard")
439     {
440         action = std::make_unique<HardPowerOff>(
441             powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func);
442     }
443     else if (type == "soft")
444     {
445         action = std::make_unique<SoftPowerOff>(
446             powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func);
447     }
448     else if (type == "epow")
449     {
450         action = std::make_unique<EpowPowerOff>(
451             powerOffConfig.at("service_mode_delay").get<uint32_t>(),
452             powerOffConfig.at("meltdown_delay").get<uint32_t>(), powerInterface,
453             func);
454     }
455     else
456     {
457         auto msg =
458             fmt::format("Invalid 'type' entry {} in power off config", type);
459         log<level::ERR>(msg.c_str());
460         throw std::runtime_error(msg.c_str());
461     }
462 
463     return action;
464 }
465 
466 std::vector<std::unique_ptr<PowerOffRule>>
467     getPowerOffRules(const json& obj,
468                      std::shared_ptr<PowerInterfaceBase>& powerInterface,
469                      PowerOffAction::PrePowerOffFunc& func)
470 {
471     std::vector<std::unique_ptr<PowerOffRule>> rules;
472 
473     if (!(obj.contains("fault_handling") &&
474           obj.at("fault_handling").contains("power_off_config")))
475     {
476         return rules;
477     }
478 
479     for (const auto& config : obj.at("fault_handling").at("power_off_config"))
480     {
481         auto state = getPowerOffPowerRuleState(config);
482         auto cause = getPowerOffCause(config);
483         auto action = getPowerOffAction(config, powerInterface, func);
484 
485         auto rule = std::make_unique<PowerOffRule>(
486             std::move(state), std::move(cause), std::move(action));
487         rules.push_back(std::move(rule));
488     }
489 
490     return rules;
491 }
492 
493 std::optional<size_t> getNumNonfuncRotorsBeforeError(const json& obj)
494 {
495     std::optional<size_t> num;
496 
497     if (obj.contains("fault_handling"))
498     {
499         // Defaults to 1 if not present inside of 'fault_handling'.
500         num = obj.at("fault_handling")
501                   .value("num_nonfunc_rotors_before_error", 1);
502     }
503 
504     return num;
505 }
506 
507 } // namespace phosphor::fan::monitor
508