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