1 #include "config.h"
2 
3 #include "json-config.hpp"
4 #include "ledlayout.hpp"
5 
6 #include <nlohmann/json.hpp>
7 #include <phosphor-logging/lg2.hpp>
8 #include <sdbusplus/bus.hpp>
9 #include <sdeventplus/event.hpp>
10 
11 #include <filesystem>
12 #include <fstream>
13 #include <iostream>
14 
15 namespace fs = std::filesystem;
16 
17 using Json = nlohmann::json;
18 
19 // Priority for a particular LED needs to stay SAME across all groups
20 // phosphor::led::Layout::Action can only be one of `Blink` and `On`
21 using PriorityMap =
22     std::unordered_map<std::string, phosphor::led::Layout::Action>;
23 
24 /** @brief Parse LED JSON file and output Json object
25  *
26  *  @param[in] path - path of LED JSON file
27  *
28  *  @return const Json - Json object
29  */
30 Json readJson(const fs::path& path)
31 {
32     if (!fs::exists(path) || fs::is_empty(path))
33     {
34         lg2::error("Incorrect File Path or empty file, FILE_PATH = {PATH}",
35                    "PATH", path);
36         throw std::runtime_error("Incorrect File Path or empty file");
37     }
38 
39     try
40     {
41         std::ifstream jsonFile(path);
42         return Json::parse(jsonFile);
43     }
44     catch (const std::exception& e)
45     {
46         lg2::error(
47             "Failed to parse config file, ERROR = {ERROR}, FILE_PATH = {PATH}",
48             "ERROR", e, "PATH", path);
49         throw std::runtime_error("Failed to parse config file");
50     }
51 }
52 
53 /** @brief Returns action enum based on string
54  *
55  *  @param[in] action - action string
56  *
57  *  @return Action - action enum (On/Blink)
58  */
59 phosphor::led::Layout::Action getAction(const std::string& action)
60 {
61     assert(action == "On" || action == "Blink");
62 
63     return action == "Blink" ? phosphor::led::Layout::Action::Blink
64                              : phosphor::led::Layout::Action::On;
65 }
66 
67 /** @brief Validate the Priority of an LED is same across ALL groups
68  *
69  *  @param[in] name - led name member of each group
70  *  @param[in] priority - member priority of each group
71  *  @param[out] priorityMap - std::unordered_map, key:name, value:priority
72  *
73  *  @return
74  */
75 void validatePriority(const std::string& name,
76                       const phosphor::led::Layout::Action& priority,
77                       PriorityMap& priorityMap)
78 {
79     auto iter = priorityMap.find(name);
80     if (iter == priorityMap.end())
81     {
82         priorityMap.emplace(name, priority);
83         return;
84     }
85 
86     if (iter->second != priority)
87     {
88         lg2::error(
89             "Priority of LED is not same across all, Name = {NAME}, Old Priority = {OLD_PRIO}, New Priority = {NEW_PRIO}",
90             "NAME", name, "OLD_PRIO", int(iter->second), "NEW_PRIO",
91             int(priority));
92 
93         throw std::runtime_error(
94             "Priority of at least one LED is not same across groups");
95     }
96 }
97 
98 static void loadJsonConfigV1GroupMember(const Json& member,
99                                         PriorityMap& priorityMap,
100                                         phosphor::led::ActionSet& ledActions)
101 {
102     auto name = member.value("Name", "");
103     auto action = getAction(member.value("Action", ""));
104     uint8_t dutyOn = member.value("DutyOn", 50);
105     uint16_t period = member.value("Period", 0);
106 
107     // Since only have Blink/On and default priority is Blink
108     auto priority = getAction(member.value("Priority", "Blink"));
109 
110     // Same LEDs can be part of multiple groups. However, their
111     // priorities across groups need to match.
112     validatePriority(name, priority, priorityMap);
113 
114     phosphor::led::Layout::LedAction ledAction{name, action, dutyOn, period,
115                                                priority};
116     ledActions.emplace(ledAction);
117 }
118 
119 static void loadJsonConfigV1Group(const Json& entry,
120                                   phosphor::led::GroupMap& ledMap,
121                                   PriorityMap& priorityMap)
122 {
123     const Json empty{};
124 
125     fs::path tmpPath("/xyz/openbmc_project/led/groups");
126 
127     const std::string groupName = entry.value("group", "");
128 
129     tmpPath /= groupName;
130     auto objpath = tmpPath.string();
131     auto members = entry.value("members", empty);
132 
133     lg2::debug("config for '{GROUP}'", "GROUP", groupName);
134 
135     phosphor::led::ActionSet ledActions{};
136     for (const auto& member : members)
137     {
138         loadJsonConfigV1GroupMember(member, priorityMap, ledActions);
139     }
140 
141     // Generated an std::unordered_map of LedGroupNames to std::set of LEDs
142     // containing the name and properties.
143     ledMap.emplace(objpath, ledActions);
144 }
145 
146 /** @brief Load JSON config and return led map (JSON version 1)
147  *
148  *  @return phosphor::led::GroupMap
149  */
150 const phosphor::led::GroupMap loadJsonConfigV1(const Json& json)
151 {
152     phosphor::led::GroupMap ledMap{};
153     PriorityMap priorityMap{};
154 
155     // define the default JSON as empty
156     const Json empty{};
157     auto leds = json.value("leds", empty);
158 
159     for (const auto& entry : leds)
160     {
161         loadJsonConfigV1Group(entry, ledMap, priorityMap);
162     }
163 
164     return ledMap;
165 }
166 
167 /** @brief Load JSON config and return led map
168  *
169  *  @return phosphor::led::GroupMap
170  */
171 const phosphor::led::GroupMap loadJsonConfig(const fs::path& path)
172 {
173     auto json = readJson(path);
174 
175     auto version = json.value("version", 1);
176     switch (version)
177     {
178         case 1:
179             return loadJsonConfigV1(json);
180 
181         default:
182             lg2::error("Unsupported JSON Version: {VERSION}", "VERSION",
183                        version);
184             throw std::runtime_error("Unsupported version");
185     }
186 
187     return phosphor::led::GroupMap{};
188 }
189 
190 /** @brief Get led map from LED groups JSON config
191  *
192  *  @param[in] config - Path to the JSON config.
193  *  @return phosphor::led::GroupMap
194  *
195  *  @note if config is an empty string, daemon will interrogate dbus for
196  *        compatible strings.
197  */
198 const phosphor::led::GroupMap getSystemLedMap(fs::path config)
199 {
200     if (config.empty())
201     {
202         config = phosphor::led::getJsonConfig();
203     }
204 
205     return loadJsonConfig(config);
206 }
207