xref: /openbmc/bmcweb/features/redfish/lib/sensors.hpp (revision c1343bf6a51b22b85a0521050948ad6026027fc8)
108777fb0SLewanczyk, Dawid /*
208777fb0SLewanczyk, Dawid // Copyright (c) 2018 Intel Corporation
308777fb0SLewanczyk, Dawid //
408777fb0SLewanczyk, Dawid // Licensed under the Apache License, Version 2.0 (the "License");
508777fb0SLewanczyk, Dawid // you may not use this file except in compliance with the License.
608777fb0SLewanczyk, Dawid // You may obtain a copy of the License at
708777fb0SLewanczyk, Dawid //
808777fb0SLewanczyk, Dawid //      http://www.apache.org/licenses/LICENSE-2.0
908777fb0SLewanczyk, Dawid //
1008777fb0SLewanczyk, Dawid // Unless required by applicable law or agreed to in writing, software
1108777fb0SLewanczyk, Dawid // distributed under the License is distributed on an "AS IS" BASIS,
1208777fb0SLewanczyk, Dawid // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1308777fb0SLewanczyk, Dawid // See the License for the specific language governing permissions and
1408777fb0SLewanczyk, Dawid // limitations under the License.
1508777fb0SLewanczyk, Dawid */
1608777fb0SLewanczyk, Dawid #pragma once
1708777fb0SLewanczyk, Dawid 
187e860f15SJohn Edward Broadbent #include <app.hpp>
1911ba3979SEd Tanous #include <boost/algorithm/string/classification.hpp>
201d7c0054SEd Tanous #include <boost/algorithm/string/find.hpp>
211d7c0054SEd Tanous #include <boost/algorithm/string/predicate.hpp>
2208777fb0SLewanczyk, Dawid #include <boost/algorithm/string/split.hpp>
2308777fb0SLewanczyk, Dawid #include <boost/range/algorithm/replace_copy_if.hpp>
241abe55efSEd Tanous #include <dbus_singleton.hpp>
25168e20c1SEd Tanous #include <dbus_utility.hpp>
2645ca1b86SEd Tanous #include <query.hpp>
27ed398213SEd Tanous #include <registries/privilege_registry.hpp>
281e1e598dSJonathan Doman #include <sdbusplus/asio/property.hpp>
2986d89ed7SKrzysztof Grobelny #include <sdbusplus/unpack_properties.hpp>
3086d89ed7SKrzysztof Grobelny #include <utils/dbus_utils.hpp>
31413961deSRichard Marian Thomaiyar #include <utils/json_utils.hpp>
32928fefb9SNan Zhou #include <utils/query_param.hpp>
331214b7e7SGunnar Mills 
341214b7e7SGunnar Mills #include <cmath>
35fe04d49cSNan Zhou #include <iterator>
36fe04d49cSNan Zhou #include <map>
37fe04d49cSNan Zhou #include <set>
38b5a76932SEd Tanous #include <utility>
39abf2add6SEd Tanous #include <variant>
4008777fb0SLewanczyk, Dawid 
411abe55efSEd Tanous namespace redfish
421abe55efSEd Tanous {
4308777fb0SLewanczyk, Dawid 
44a0ec28b6SAdrian Ambrożewicz namespace sensors
45a0ec28b6SAdrian Ambrożewicz {
46a0ec28b6SAdrian Ambrożewicz namespace node
47a0ec28b6SAdrian Ambrożewicz {
48a0ec28b6SAdrian Ambrożewicz static constexpr std::string_view power = "Power";
49a0ec28b6SAdrian Ambrożewicz static constexpr std::string_view sensors = "Sensors";
50a0ec28b6SAdrian Ambrożewicz static constexpr std::string_view thermal = "Thermal";
51a0ec28b6SAdrian Ambrożewicz } // namespace node
52a0ec28b6SAdrian Ambrożewicz 
5302da7c5aSEd Tanous // clang-format off
54a0ec28b6SAdrian Ambrożewicz namespace dbus
55a0ec28b6SAdrian Ambrożewicz {
564ee8e211SEd Tanous static auto powerPaths = std::to_array<std::string_view>({
5702da7c5aSEd Tanous     "/xyz/openbmc_project/sensors/voltage",
5802da7c5aSEd Tanous     "/xyz/openbmc_project/sensors/power"
5902da7c5aSEd Tanous });
60c2bf7f99SWludzik, Jozef 
614ee8e211SEd Tanous static auto sensorPaths = std::to_array<std::string_view>({
6202da7c5aSEd Tanous     "/xyz/openbmc_project/sensors/power",
63a0ec28b6SAdrian Ambrożewicz     "/xyz/openbmc_project/sensors/current",
647088690cSBasheer Ahmed Muddebihal     "/xyz/openbmc_project/sensors/airflow",
655deabed9SGunnar Mills     "/xyz/openbmc_project/sensors/humidity",
66e8204933SGeorge Liu #ifdef BMCWEB_NEW_POWERSUBSYSTEM_THERMALSUBSYSTEM
67e8204933SGeorge Liu     "/xyz/openbmc_project/sensors/voltage",
68e8204933SGeorge Liu     "/xyz/openbmc_project/sensors/fan_tach",
69e8204933SGeorge Liu     "/xyz/openbmc_project/sensors/temperature",
70e8204933SGeorge Liu     "/xyz/openbmc_project/sensors/fan_pwm",
71e8204933SGeorge Liu     "/xyz/openbmc_project/sensors/altitude",
72e8204933SGeorge Liu     "/xyz/openbmc_project/sensors/energy",
73e8204933SGeorge Liu #endif
7402da7c5aSEd Tanous     "/xyz/openbmc_project/sensors/utilization"
7502da7c5aSEd Tanous });
7602da7c5aSEd Tanous 
774ee8e211SEd Tanous static auto thermalPaths = std::to_array<std::string_view>({
7802da7c5aSEd Tanous     "/xyz/openbmc_project/sensors/fan_tach",
79a0ec28b6SAdrian Ambrożewicz     "/xyz/openbmc_project/sensors/temperature",
8002da7c5aSEd Tanous     "/xyz/openbmc_project/sensors/fan_pwm"
8102da7c5aSEd Tanous });
8202da7c5aSEd Tanous 
83c2bf7f99SWludzik, Jozef } // namespace dbus
8402da7c5aSEd Tanous // clang-format on
8502da7c5aSEd Tanous 
8602da7c5aSEd Tanous using sensorPair = std::pair<std::string_view, std::span<std::string_view>>;
8702da7c5aSEd Tanous static constexpr std::array<sensorPair, 3> paths = {
8802da7c5aSEd Tanous     {{node::power, std::span<std::string_view>(dbus::powerPaths)},
8902da7c5aSEd Tanous      {node::sensors, std::span<std::string_view>(dbus::sensorPaths)},
9002da7c5aSEd Tanous      {node::thermal, std::span<std::string_view>(dbus::thermalPaths)}}};
91c2bf7f99SWludzik, Jozef 
921d7c0054SEd Tanous inline std::string_view toReadingType(std::string_view sensorType)
93c2bf7f99SWludzik, Jozef {
94c2bf7f99SWludzik, Jozef     if (sensorType == "voltage")
95c2bf7f99SWludzik, Jozef     {
96c2bf7f99SWludzik, Jozef         return "Voltage";
97c2bf7f99SWludzik, Jozef     }
98c2bf7f99SWludzik, Jozef     if (sensorType == "power")
99c2bf7f99SWludzik, Jozef     {
100c2bf7f99SWludzik, Jozef         return "Power";
101c2bf7f99SWludzik, Jozef     }
102c2bf7f99SWludzik, Jozef     if (sensorType == "current")
103c2bf7f99SWludzik, Jozef     {
104c2bf7f99SWludzik, Jozef         return "Current";
105c2bf7f99SWludzik, Jozef     }
106c2bf7f99SWludzik, Jozef     if (sensorType == "fan_tach")
107c2bf7f99SWludzik, Jozef     {
108c2bf7f99SWludzik, Jozef         return "Rotational";
109c2bf7f99SWludzik, Jozef     }
110c2bf7f99SWludzik, Jozef     if (sensorType == "temperature")
111c2bf7f99SWludzik, Jozef     {
112c2bf7f99SWludzik, Jozef         return "Temperature";
113c2bf7f99SWludzik, Jozef     }
114c2bf7f99SWludzik, Jozef     if (sensorType == "fan_pwm" || sensorType == "utilization")
115c2bf7f99SWludzik, Jozef     {
116c2bf7f99SWludzik, Jozef         return "Percent";
117c2bf7f99SWludzik, Jozef     }
1185deabed9SGunnar Mills     if (sensorType == "humidity")
1195deabed9SGunnar Mills     {
1205deabed9SGunnar Mills         return "Humidity";
1215deabed9SGunnar Mills     }
122c2bf7f99SWludzik, Jozef     if (sensorType == "altitude")
123c2bf7f99SWludzik, Jozef     {
124c2bf7f99SWludzik, Jozef         return "Altitude";
125c2bf7f99SWludzik, Jozef     }
126c2bf7f99SWludzik, Jozef     if (sensorType == "airflow")
127c2bf7f99SWludzik, Jozef     {
128c2bf7f99SWludzik, Jozef         return "AirFlow";
129c2bf7f99SWludzik, Jozef     }
130c2bf7f99SWludzik, Jozef     if (sensorType == "energy")
131c2bf7f99SWludzik, Jozef     {
132c2bf7f99SWludzik, Jozef         return "EnergyJoules";
133c2bf7f99SWludzik, Jozef     }
134c2bf7f99SWludzik, Jozef     return "";
135c2bf7f99SWludzik, Jozef }
136c2bf7f99SWludzik, Jozef 
1371d7c0054SEd Tanous inline std::string_view toReadingUnits(std::string_view sensorType)
138c2bf7f99SWludzik, Jozef {
139c2bf7f99SWludzik, Jozef     if (sensorType == "voltage")
140c2bf7f99SWludzik, Jozef     {
141c2bf7f99SWludzik, Jozef         return "V";
142c2bf7f99SWludzik, Jozef     }
143c2bf7f99SWludzik, Jozef     if (sensorType == "power")
144c2bf7f99SWludzik, Jozef     {
145c2bf7f99SWludzik, Jozef         return "W";
146c2bf7f99SWludzik, Jozef     }
147c2bf7f99SWludzik, Jozef     if (sensorType == "current")
148c2bf7f99SWludzik, Jozef     {
149c2bf7f99SWludzik, Jozef         return "A";
150c2bf7f99SWludzik, Jozef     }
151c2bf7f99SWludzik, Jozef     if (sensorType == "fan_tach")
152c2bf7f99SWludzik, Jozef     {
153c2bf7f99SWludzik, Jozef         return "RPM";
154c2bf7f99SWludzik, Jozef     }
155c2bf7f99SWludzik, Jozef     if (sensorType == "temperature")
156c2bf7f99SWludzik, Jozef     {
157c2bf7f99SWludzik, Jozef         return "Cel";
158c2bf7f99SWludzik, Jozef     }
1595deabed9SGunnar Mills     if (sensorType == "fan_pwm" || sensorType == "utilization" ||
1605deabed9SGunnar Mills         sensorType == "humidity")
161c2bf7f99SWludzik, Jozef     {
162c2bf7f99SWludzik, Jozef         return "%";
163c2bf7f99SWludzik, Jozef     }
164c2bf7f99SWludzik, Jozef     if (sensorType == "altitude")
165c2bf7f99SWludzik, Jozef     {
166c2bf7f99SWludzik, Jozef         return "m";
167c2bf7f99SWludzik, Jozef     }
168c2bf7f99SWludzik, Jozef     if (sensorType == "airflow")
169c2bf7f99SWludzik, Jozef     {
170c2bf7f99SWludzik, Jozef         return "cft_i/min";
171c2bf7f99SWludzik, Jozef     }
172c2bf7f99SWludzik, Jozef     if (sensorType == "energy")
173c2bf7f99SWludzik, Jozef     {
174c2bf7f99SWludzik, Jozef         return "J";
175c2bf7f99SWludzik, Jozef     }
176c2bf7f99SWludzik, Jozef     return "";
177a0ec28b6SAdrian Ambrożewicz }
178a0ec28b6SAdrian Ambrożewicz } // namespace sensors
179a0ec28b6SAdrian Ambrożewicz 
18008777fb0SLewanczyk, Dawid /**
181588c3f0dSKowalski, Kamil  * SensorsAsyncResp
18208777fb0SLewanczyk, Dawid  * Gathers data needed for response processing after async calls are done
18308777fb0SLewanczyk, Dawid  */
1841abe55efSEd Tanous class SensorsAsyncResp
1851abe55efSEd Tanous {
18608777fb0SLewanczyk, Dawid   public:
187a0ec28b6SAdrian Ambrożewicz     using DataCompleteCb = std::function<void(
188a0ec28b6SAdrian Ambrożewicz         const boost::beast::http::status status,
189fe04d49cSNan Zhou         const std::map<std::string, std::string>& uriToDbus)>;
190a0ec28b6SAdrian Ambrożewicz 
191a0ec28b6SAdrian Ambrożewicz     struct SensorData
192a0ec28b6SAdrian Ambrożewicz     {
193a0ec28b6SAdrian Ambrożewicz         const std::string name;
194a0ec28b6SAdrian Ambrożewicz         std::string uri;
195a0ec28b6SAdrian Ambrożewicz         const std::string dbusPath;
196a0ec28b6SAdrian Ambrożewicz     };
197a0ec28b6SAdrian Ambrożewicz 
1988a592810SEd Tanous     SensorsAsyncResp(const std::shared_ptr<bmcweb::AsyncResp>& asyncRespIn,
1998d1b46d7Szhanghch05                      const std::string& chassisIdIn,
20002da7c5aSEd Tanous                      std::span<std::string_view> typesIn,
20102da7c5aSEd Tanous                      std::string_view subNode) :
2028a592810SEd Tanous         asyncResp(asyncRespIn),
203928fefb9SNan Zhou         chassisId(chassisIdIn), types(typesIn), chassisSubNode(subNode),
204928fefb9SNan Zhou         efficientExpand(false)
2051214b7e7SGunnar Mills     {}
20608777fb0SLewanczyk, Dawid 
207a0ec28b6SAdrian Ambrożewicz     // Store extra data about sensor mapping and return it in callback
2088a592810SEd Tanous     SensorsAsyncResp(const std::shared_ptr<bmcweb::AsyncResp>& asyncRespIn,
2098d1b46d7Szhanghch05                      const std::string& chassisIdIn,
21002da7c5aSEd Tanous                      std::span<std::string_view> typesIn,
21102da7c5aSEd Tanous                      std::string_view subNode,
212a0ec28b6SAdrian Ambrożewicz                      DataCompleteCb&& creationComplete) :
2138a592810SEd Tanous         asyncResp(asyncRespIn),
214928fefb9SNan Zhou         chassisId(chassisIdIn), types(typesIn), chassisSubNode(subNode),
215928fefb9SNan Zhou         efficientExpand(false), metadata{std::vector<SensorData>()},
216a0ec28b6SAdrian Ambrożewicz         dataComplete{std::move(creationComplete)}
217a0ec28b6SAdrian Ambrożewicz     {}
218a0ec28b6SAdrian Ambrożewicz 
219928fefb9SNan Zhou     // sensor collections expand
2208a592810SEd Tanous     SensorsAsyncResp(const std::shared_ptr<bmcweb::AsyncResp>& asyncRespIn,
221928fefb9SNan Zhou                      const std::string& chassisIdIn,
22202da7c5aSEd Tanous                      const std::span<std::string_view> typesIn,
2238a592810SEd Tanous                      const std::string_view& subNode, bool efficientExpandIn) :
2248a592810SEd Tanous         asyncResp(asyncRespIn),
225928fefb9SNan Zhou         chassisId(chassisIdIn), types(typesIn), chassisSubNode(subNode),
2268a592810SEd Tanous         efficientExpand(efficientExpandIn)
227928fefb9SNan Zhou     {}
228928fefb9SNan Zhou 
2291abe55efSEd Tanous     ~SensorsAsyncResp()
2301abe55efSEd Tanous     {
2318d1b46d7Szhanghch05         if (asyncResp->res.result() ==
2328d1b46d7Szhanghch05             boost::beast::http::status::internal_server_error)
2331abe55efSEd Tanous         {
2341abe55efSEd Tanous             // Reset the json object to clear out any data that made it in
2351abe55efSEd Tanous             // before the error happened todo(ed) handle error condition with
2361abe55efSEd Tanous             // proper code
2378d1b46d7Szhanghch05             asyncResp->res.jsonValue = nlohmann::json::object();
23808777fb0SLewanczyk, Dawid         }
239a0ec28b6SAdrian Ambrożewicz 
240a0ec28b6SAdrian Ambrożewicz         if (dataComplete && metadata)
241a0ec28b6SAdrian Ambrożewicz         {
242fe04d49cSNan Zhou             std::map<std::string, std::string> map;
2438d1b46d7Szhanghch05             if (asyncResp->res.result() == boost::beast::http::status::ok)
244a0ec28b6SAdrian Ambrożewicz             {
245a0ec28b6SAdrian Ambrożewicz                 for (auto& sensor : *metadata)
246a0ec28b6SAdrian Ambrożewicz                 {
247c1d019a6SEd Tanous                     map.emplace(sensor.uri, sensor.dbusPath);
248a0ec28b6SAdrian Ambrożewicz                 }
249a0ec28b6SAdrian Ambrożewicz             }
2508d1b46d7Szhanghch05             dataComplete(asyncResp->res.result(), map);
251a0ec28b6SAdrian Ambrożewicz         }
25208777fb0SLewanczyk, Dawid     }
253588c3f0dSKowalski, Kamil 
254ecd6a3a2SEd Tanous     SensorsAsyncResp(const SensorsAsyncResp&) = delete;
255ecd6a3a2SEd Tanous     SensorsAsyncResp(SensorsAsyncResp&&) = delete;
256ecd6a3a2SEd Tanous     SensorsAsyncResp& operator=(const SensorsAsyncResp&) = delete;
257ecd6a3a2SEd Tanous     SensorsAsyncResp& operator=(SensorsAsyncResp&&) = delete;
258ecd6a3a2SEd Tanous 
259a0ec28b6SAdrian Ambrożewicz     void addMetadata(const nlohmann::json& sensorObject,
260c1d019a6SEd Tanous                      const std::string& dbusPath)
261a0ec28b6SAdrian Ambrożewicz     {
262a0ec28b6SAdrian Ambrożewicz         if (metadata)
263a0ec28b6SAdrian Ambrożewicz         {
264c1d019a6SEd Tanous             metadata->emplace_back(SensorData{
265c1d019a6SEd Tanous                 sensorObject["Name"], sensorObject["@odata.id"], dbusPath});
266a0ec28b6SAdrian Ambrożewicz         }
267a0ec28b6SAdrian Ambrożewicz     }
268a0ec28b6SAdrian Ambrożewicz 
269a0ec28b6SAdrian Ambrożewicz     void updateUri(const std::string& name, const std::string& uri)
270a0ec28b6SAdrian Ambrożewicz     {
271a0ec28b6SAdrian Ambrożewicz         if (metadata)
272a0ec28b6SAdrian Ambrożewicz         {
273a0ec28b6SAdrian Ambrożewicz             for (auto& sensor : *metadata)
274a0ec28b6SAdrian Ambrożewicz             {
275a0ec28b6SAdrian Ambrożewicz                 if (sensor.name == name)
276a0ec28b6SAdrian Ambrożewicz                 {
277a0ec28b6SAdrian Ambrożewicz                     sensor.uri = uri;
278a0ec28b6SAdrian Ambrożewicz                 }
279a0ec28b6SAdrian Ambrożewicz             }
280a0ec28b6SAdrian Ambrożewicz         }
281a0ec28b6SAdrian Ambrożewicz     }
282a0ec28b6SAdrian Ambrożewicz 
2838d1b46d7Szhanghch05     const std::shared_ptr<bmcweb::AsyncResp> asyncResp;
284a0ec28b6SAdrian Ambrożewicz     const std::string chassisId;
28502da7c5aSEd Tanous     const std::span<std::string_view> types;
286a0ec28b6SAdrian Ambrożewicz     const std::string chassisSubNode;
287928fefb9SNan Zhou     const bool efficientExpand;
288a0ec28b6SAdrian Ambrożewicz 
289a0ec28b6SAdrian Ambrożewicz   private:
290a0ec28b6SAdrian Ambrożewicz     std::optional<std::vector<SensorData>> metadata;
291a0ec28b6SAdrian Ambrożewicz     DataCompleteCb dataComplete;
29208777fb0SLewanczyk, Dawid };
29308777fb0SLewanczyk, Dawid 
29408777fb0SLewanczyk, Dawid /**
295d500549bSAnthony Wilson  * Possible states for physical inventory leds
296d500549bSAnthony Wilson  */
297d500549bSAnthony Wilson enum class LedState
298d500549bSAnthony Wilson {
299d500549bSAnthony Wilson     OFF,
300d500549bSAnthony Wilson     ON,
301d500549bSAnthony Wilson     BLINK,
302d500549bSAnthony Wilson     UNKNOWN
303d500549bSAnthony Wilson };
304d500549bSAnthony Wilson 
305d500549bSAnthony Wilson /**
306adc4f0dbSShawn McCarney  * D-Bus inventory item associated with one or more sensors.
307adc4f0dbSShawn McCarney  */
308adc4f0dbSShawn McCarney class InventoryItem
309adc4f0dbSShawn McCarney {
310adc4f0dbSShawn McCarney   public:
3114e23a444SEd Tanous     explicit InventoryItem(const std::string& objPath) : objectPath(objPath)
312adc4f0dbSShawn McCarney     {
313adc4f0dbSShawn McCarney         // Set inventory item name to last node of object path
31428aa8de5SGeorge Liu         sdbusplus::message::object_path path(objectPath);
31528aa8de5SGeorge Liu         name = path.filename();
31628aa8de5SGeorge Liu         if (name.empty())
317adc4f0dbSShawn McCarney         {
31828aa8de5SGeorge Liu             BMCWEB_LOG_ERROR << "Failed to find '/' in " << objectPath;
319adc4f0dbSShawn McCarney         }
320adc4f0dbSShawn McCarney     }
321adc4f0dbSShawn McCarney 
322adc4f0dbSShawn McCarney     std::string objectPath;
323adc4f0dbSShawn McCarney     std::string name;
324e05aec50SEd Tanous     bool isPresent = true;
325e05aec50SEd Tanous     bool isFunctional = true;
326e05aec50SEd Tanous     bool isPowerSupply = false;
327e05aec50SEd Tanous     int powerSupplyEfficiencyPercent = -1;
328adc4f0dbSShawn McCarney     std::string manufacturer;
329adc4f0dbSShawn McCarney     std::string model;
330adc4f0dbSShawn McCarney     std::string partNumber;
331adc4f0dbSShawn McCarney     std::string serialNumber;
332adc4f0dbSShawn McCarney     std::set<std::string> sensors;
333d500549bSAnthony Wilson     std::string ledObjectPath;
334e05aec50SEd Tanous     LedState ledState = LedState::UNKNOWN;
335adc4f0dbSShawn McCarney };
336adc4f0dbSShawn McCarney 
337adc4f0dbSShawn McCarney /**
338413961deSRichard Marian Thomaiyar  * @brief Get objects with connection necessary for sensors
339588c3f0dSKowalski, Kamil  * @param SensorsAsyncResp Pointer to object holding response data
34008777fb0SLewanczyk, Dawid  * @param sensorNames Sensors retrieved from chassis
34108777fb0SLewanczyk, Dawid  * @param callback Callback for processing gathered connections
34208777fb0SLewanczyk, Dawid  */
34308777fb0SLewanczyk, Dawid template <typename Callback>
344413961deSRichard Marian Thomaiyar void getObjectsWithConnection(
34581ce609eSEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
346fe04d49cSNan Zhou     const std::shared_ptr<std::set<std::string>>& sensorNames,
3471abe55efSEd Tanous     Callback&& callback)
3481abe55efSEd Tanous {
349413961deSRichard Marian Thomaiyar     BMCWEB_LOG_DEBUG << "getObjectsWithConnection enter";
35003b5bae3SJames Feist     const std::string path = "/xyz/openbmc_project/sensors";
35108777fb0SLewanczyk, Dawid     const std::array<std::string, 1> interfaces = {
35208777fb0SLewanczyk, Dawid         "xyz.openbmc_project.Sensor.Value"};
35308777fb0SLewanczyk, Dawid 
35408777fb0SLewanczyk, Dawid     // Response handler for parsing objects subtree
355002d39b4SEd Tanous     auto respHandler =
356002d39b4SEd Tanous         [callback{std::forward<Callback>(callback)}, sensorsAsyncResp,
357002d39b4SEd Tanous          sensorNames](const boost::system::error_code ec,
358002d39b4SEd Tanous                       const dbus::utility::MapperGetSubTreeResponse& subtree) {
359413961deSRichard Marian Thomaiyar         BMCWEB_LOG_DEBUG << "getObjectsWithConnection resp_handler enter";
3601abe55efSEd Tanous         if (ec)
3611abe55efSEd Tanous         {
3628d1b46d7Szhanghch05             messages::internalError(sensorsAsyncResp->asyncResp->res);
363413961deSRichard Marian Thomaiyar             BMCWEB_LOG_ERROR
364413961deSRichard Marian Thomaiyar                 << "getObjectsWithConnection resp_handler: Dbus error " << ec;
36508777fb0SLewanczyk, Dawid             return;
36608777fb0SLewanczyk, Dawid         }
36708777fb0SLewanczyk, Dawid 
36855c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "Found " << subtree.size() << " subtrees";
36908777fb0SLewanczyk, Dawid 
37008777fb0SLewanczyk, Dawid         // Make unique list of connections only for requested sensor types and
37108777fb0SLewanczyk, Dawid         // found in the chassis
372fe04d49cSNan Zhou         std::set<std::string> connections;
373413961deSRichard Marian Thomaiyar         std::set<std::pair<std::string, std::string>> objectsWithConnection;
37408777fb0SLewanczyk, Dawid 
37549c53ac9SJohnathan Mantey         BMCWEB_LOG_DEBUG << "sensorNames list count: " << sensorNames->size();
37649c53ac9SJohnathan Mantey         for (const std::string& tsensor : *sensorNames)
3771abe55efSEd Tanous         {
37855c7b7a2SEd Tanous             BMCWEB_LOG_DEBUG << "Sensor to find: " << tsensor;
37908777fb0SLewanczyk, Dawid         }
38008777fb0SLewanczyk, Dawid 
38108777fb0SLewanczyk, Dawid         for (const std::pair<
38208777fb0SLewanczyk, Dawid                  std::string,
38308777fb0SLewanczyk, Dawid                  std::vector<std::pair<std::string, std::vector<std::string>>>>&
3841abe55efSEd Tanous                  object : subtree)
3851abe55efSEd Tanous         {
38649c53ac9SJohnathan Mantey             if (sensorNames->find(object.first) != sensorNames->end())
3871abe55efSEd Tanous             {
38849c53ac9SJohnathan Mantey                 for (const std::pair<std::string, std::vector<std::string>>&
3891abe55efSEd Tanous                          objData : object.second)
3901abe55efSEd Tanous                 {
39149c53ac9SJohnathan Mantey                     BMCWEB_LOG_DEBUG << "Adding connection: " << objData.first;
39208777fb0SLewanczyk, Dawid                     connections.insert(objData.first);
393de629b6eSShawn McCarney                     objectsWithConnection.insert(
394de629b6eSShawn McCarney                         std::make_pair(object.first, objData.first));
39508777fb0SLewanczyk, Dawid                 }
39608777fb0SLewanczyk, Dawid             }
39708777fb0SLewanczyk, Dawid         }
39855c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "Found " << connections.size() << " connections";
399413961deSRichard Marian Thomaiyar         callback(std::move(connections), std::move(objectsWithConnection));
400413961deSRichard Marian Thomaiyar         BMCWEB_LOG_DEBUG << "getObjectsWithConnection resp_handler exit";
40108777fb0SLewanczyk, Dawid     };
40208777fb0SLewanczyk, Dawid     // Make call to ObjectMapper to find all sensors objects
40355c7b7a2SEd Tanous     crow::connections::systemBus->async_method_call(
40455c7b7a2SEd Tanous         std::move(respHandler), "xyz.openbmc_project.ObjectMapper",
4051abe55efSEd Tanous         "/xyz/openbmc_project/object_mapper",
4061abe55efSEd Tanous         "xyz.openbmc_project.ObjectMapper", "GetSubTree", path, 2, interfaces);
407413961deSRichard Marian Thomaiyar     BMCWEB_LOG_DEBUG << "getObjectsWithConnection exit";
408413961deSRichard Marian Thomaiyar }
409413961deSRichard Marian Thomaiyar 
410413961deSRichard Marian Thomaiyar /**
411413961deSRichard Marian Thomaiyar  * @brief Create connections necessary for sensors
412413961deSRichard Marian Thomaiyar  * @param SensorsAsyncResp Pointer to object holding response data
413413961deSRichard Marian Thomaiyar  * @param sensorNames Sensors retrieved from chassis
414413961deSRichard Marian Thomaiyar  * @param callback Callback for processing gathered connections
415413961deSRichard Marian Thomaiyar  */
416413961deSRichard Marian Thomaiyar template <typename Callback>
417fe04d49cSNan Zhou void getConnections(std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp,
418fe04d49cSNan Zhou                     const std::shared_ptr<std::set<std::string>> sensorNames,
419413961deSRichard Marian Thomaiyar                     Callback&& callback)
420413961deSRichard Marian Thomaiyar {
421413961deSRichard Marian Thomaiyar     auto objectsWithConnectionCb =
422fe04d49cSNan Zhou         [callback](const std::set<std::string>& connections,
423413961deSRichard Marian Thomaiyar                    const std::set<std::pair<std::string, std::string>>&
4243174e4dfSEd Tanous                    /*objectsWithConnection*/) { callback(connections); };
42581ce609eSEd Tanous     getObjectsWithConnection(sensorsAsyncResp, sensorNames,
426413961deSRichard Marian Thomaiyar                              std::move(objectsWithConnectionCb));
42708777fb0SLewanczyk, Dawid }
42808777fb0SLewanczyk, Dawid 
42908777fb0SLewanczyk, Dawid /**
43049c53ac9SJohnathan Mantey  * @brief Shrinks the list of sensors for processing
43149c53ac9SJohnathan Mantey  * @param SensorsAysncResp  The class holding the Redfish response
43249c53ac9SJohnathan Mantey  * @param allSensors  A list of all the sensors associated to the
43349c53ac9SJohnathan Mantey  * chassis element (i.e. baseboard, front panel, etc...)
43449c53ac9SJohnathan Mantey  * @param activeSensors A list that is a reduction of the incoming
43549c53ac9SJohnathan Mantey  * allSensors list.  Eliminate Thermal sensors when a Power request is
43649c53ac9SJohnathan Mantey  * made, and eliminate Power sensors when a Thermal request is made.
43749c53ac9SJohnathan Mantey  */
43823a21a1cSEd Tanous inline void reduceSensorList(
4397f1cc26dSEd Tanous     crow::Response& res, std::string_view chassisSubNode,
4407f1cc26dSEd Tanous     std::span<std::string_view> sensorTypes,
44149c53ac9SJohnathan Mantey     const std::vector<std::string>* allSensors,
442fe04d49cSNan Zhou     const std::shared_ptr<std::set<std::string>>& activeSensors)
44349c53ac9SJohnathan Mantey {
44449c53ac9SJohnathan Mantey     if ((allSensors == nullptr) || (activeSensors == nullptr))
44549c53ac9SJohnathan Mantey     {
4467f1cc26dSEd Tanous         messages::resourceNotFound(res, chassisSubNode,
4477f1cc26dSEd Tanous                                    chassisSubNode == sensors::node::thermal
448a0ec28b6SAdrian Ambrożewicz                                        ? "Temperatures"
44949c53ac9SJohnathan Mantey                                        : "Voltages");
45049c53ac9SJohnathan Mantey 
45149c53ac9SJohnathan Mantey         return;
45249c53ac9SJohnathan Mantey     }
45349c53ac9SJohnathan Mantey     if (allSensors->empty())
45449c53ac9SJohnathan Mantey     {
45549c53ac9SJohnathan Mantey         // Nothing to do, the activeSensors object is also empty
45649c53ac9SJohnathan Mantey         return;
45749c53ac9SJohnathan Mantey     }
45849c53ac9SJohnathan Mantey 
4597f1cc26dSEd Tanous     for (std::string_view type : sensorTypes)
46049c53ac9SJohnathan Mantey     {
46149c53ac9SJohnathan Mantey         for (const std::string& sensor : *allSensors)
46249c53ac9SJohnathan Mantey         {
46311ba3979SEd Tanous             if (sensor.starts_with(type))
46449c53ac9SJohnathan Mantey             {
46549c53ac9SJohnathan Mantey                 activeSensors->emplace(sensor);
46649c53ac9SJohnathan Mantey             }
46749c53ac9SJohnathan Mantey         }
46849c53ac9SJohnathan Mantey     }
46949c53ac9SJohnathan Mantey }
47049c53ac9SJohnathan Mantey 
4717f1cc26dSEd Tanous /*
4727f1cc26dSEd Tanous  *Populates the top level collection for a given subnode.  Populates
4737f1cc26dSEd Tanous  *SensorCollection, Power, or Thermal schemas.
4747f1cc26dSEd Tanous  *
4757f1cc26dSEd Tanous  * */
4767f1cc26dSEd Tanous inline void populateChassisNode(nlohmann::json& jsonValue,
4777f1cc26dSEd Tanous                                 std::string_view chassisSubNode)
4787f1cc26dSEd Tanous {
4797f1cc26dSEd Tanous     if (chassisSubNode == sensors::node::power)
4807f1cc26dSEd Tanous     {
4817f1cc26dSEd Tanous         jsonValue["@odata.type"] = "#Power.v1_5_2.Power";
4827f1cc26dSEd Tanous     }
4837f1cc26dSEd Tanous     else if (chassisSubNode == sensors::node::thermal)
4847f1cc26dSEd Tanous     {
4857f1cc26dSEd Tanous         jsonValue["@odata.type"] = "#Thermal.v1_4_0.Thermal";
4867f1cc26dSEd Tanous         jsonValue["Fans"] = nlohmann::json::array();
4877f1cc26dSEd Tanous         jsonValue["Temperatures"] = nlohmann::json::array();
4887f1cc26dSEd Tanous     }
4897f1cc26dSEd Tanous     else if (chassisSubNode == sensors::node::sensors)
4907f1cc26dSEd Tanous     {
4917f1cc26dSEd Tanous         jsonValue["@odata.type"] = "#SensorCollection.SensorCollection";
4927f1cc26dSEd Tanous         jsonValue["Description"] = "Collection of Sensors for this Chassis";
4937f1cc26dSEd Tanous         jsonValue["Members"] = nlohmann::json::array();
4947f1cc26dSEd Tanous         jsonValue["Members@odata.count"] = 0;
4957f1cc26dSEd Tanous     }
4967f1cc26dSEd Tanous 
4977f1cc26dSEd Tanous     if (chassisSubNode != sensors::node::sensors)
4987f1cc26dSEd Tanous     {
4997f1cc26dSEd Tanous         jsonValue["Id"] = chassisSubNode;
5007f1cc26dSEd Tanous     }
5017f1cc26dSEd Tanous     jsonValue["Name"] = chassisSubNode;
5027f1cc26dSEd Tanous }
5037f1cc26dSEd Tanous 
50449c53ac9SJohnathan Mantey /**
50508777fb0SLewanczyk, Dawid  * @brief Retrieves requested chassis sensors and redundancy data from DBus .
506588c3f0dSKowalski, Kamil  * @param SensorsAsyncResp   Pointer to object holding response data
50708777fb0SLewanczyk, Dawid  * @param callback  Callback for next step in gathered sensor processing
50808777fb0SLewanczyk, Dawid  */
50908777fb0SLewanczyk, Dawid template <typename Callback>
5107f1cc26dSEd Tanous void getChassis(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
5117f1cc26dSEd Tanous                 std::string_view chassisId, std::string_view chassisSubNode,
5127f1cc26dSEd Tanous                 std::span<std::string_view> sensorTypes, Callback&& callback)
5131abe55efSEd Tanous {
51455c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "getChassis enter";
515adc4f0dbSShawn McCarney     const std::array<const char*, 2> interfaces = {
51649c53ac9SJohnathan Mantey         "xyz.openbmc_project.Inventory.Item.Board",
517adc4f0dbSShawn McCarney         "xyz.openbmc_project.Inventory.Item.Chassis"};
518002d39b4SEd Tanous     auto respHandler =
5197f1cc26dSEd Tanous         [callback{std::forward<Callback>(callback)}, asyncResp,
5207f1cc26dSEd Tanous          chassisIdStr{std::string(chassisId)},
5217f1cc26dSEd Tanous          chassisSubNode{std::string(chassisSubNode)}, sensorTypes](
52249c53ac9SJohnathan Mantey             const boost::system::error_code ec,
523002d39b4SEd Tanous             const dbus::utility::MapperGetSubTreePathsResponse& chassisPaths) {
52455c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "getChassis respHandler enter";
5251abe55efSEd Tanous         if (ec)
5261abe55efSEd Tanous         {
52755c7b7a2SEd Tanous             BMCWEB_LOG_ERROR << "getChassis respHandler DBUS error: " << ec;
5287f1cc26dSEd Tanous             messages::internalError(asyncResp->res);
52908777fb0SLewanczyk, Dawid             return;
53008777fb0SLewanczyk, Dawid         }
53149c53ac9SJohnathan Mantey         const std::string* chassisPath = nullptr;
53249c53ac9SJohnathan Mantey         std::string chassisName;
53349c53ac9SJohnathan Mantey         for (const std::string& chassis : chassisPaths)
5341abe55efSEd Tanous         {
53528aa8de5SGeorge Liu             sdbusplus::message::object_path path(chassis);
53628aa8de5SGeorge Liu             chassisName = path.filename();
53728aa8de5SGeorge Liu             if (chassisName.empty())
5381abe55efSEd Tanous             {
53949c53ac9SJohnathan Mantey                 BMCWEB_LOG_ERROR << "Failed to find '/' in " << chassis;
540daf36e2eSEd Tanous                 continue;
541daf36e2eSEd Tanous             }
5427f1cc26dSEd Tanous             if (chassisName == chassisIdStr)
5431abe55efSEd Tanous             {
54449c53ac9SJohnathan Mantey                 chassisPath = &chassis;
54549c53ac9SJohnathan Mantey                 break;
546daf36e2eSEd Tanous             }
54749c53ac9SJohnathan Mantey         }
54849c53ac9SJohnathan Mantey         if (chassisPath == nullptr)
5491abe55efSEd Tanous         {
5507f1cc26dSEd Tanous             messages::resourceNotFound(asyncResp->res, "Chassis", chassisIdStr);
55149c53ac9SJohnathan Mantey             return;
5521abe55efSEd Tanous         }
5537f1cc26dSEd Tanous         populateChassisNode(asyncResp->res.jsonValue, chassisSubNode);
55408777fb0SLewanczyk, Dawid 
5557f1cc26dSEd Tanous         asyncResp->res.jsonValue["@odata.id"] =
5567f1cc26dSEd Tanous             "/redfish/v1/Chassis/" + chassisIdStr + "/" + chassisSubNode;
55795a3ecadSAnthony Wilson 
5588fb49dd6SShawn McCarney         // Get the list of all sensors for this Chassis element
5598fb49dd6SShawn McCarney         std::string sensorPath = *chassisPath + "/all_sensors";
5601e1e598dSJonathan Doman         sdbusplus::asio::getProperty<std::vector<std::string>>(
5611e1e598dSJonathan Doman             *crow::connections::systemBus, "xyz.openbmc_project.ObjectMapper",
5621e1e598dSJonathan Doman             sensorPath, "xyz.openbmc_project.Association", "endpoints",
5637f1cc26dSEd Tanous             [asyncResp, chassisSubNode, sensorTypes,
564f94c4ecfSEd Tanous              callback{std::forward<const Callback>(callback)}](
565271584abSEd Tanous                 const boost::system::error_code& e,
5661e1e598dSJonathan Doman                 const std::vector<std::string>& nodeSensorList) {
567271584abSEd Tanous             if (e)
56849c53ac9SJohnathan Mantey             {
569271584abSEd Tanous                 if (e.value() != EBADR)
57049c53ac9SJohnathan Mantey                 {
5717f1cc26dSEd Tanous                     messages::internalError(asyncResp->res);
57249c53ac9SJohnathan Mantey                     return;
57349c53ac9SJohnathan Mantey                 }
57449c53ac9SJohnathan Mantey             }
575fe04d49cSNan Zhou             const std::shared_ptr<std::set<std::string>> culledSensorList =
576fe04d49cSNan Zhou                 std::make_shared<std::set<std::string>>();
5777f1cc26dSEd Tanous             reduceSensorList(asyncResp->res, chassisSubNode, sensorTypes,
5787f1cc26dSEd Tanous                              &nodeSensorList, culledSensorList);
5797f1cc26dSEd Tanous             BMCWEB_LOG_DEBUG << "Finishing with " << culledSensorList->size();
58049c53ac9SJohnathan Mantey             callback(culledSensorList);
5811e1e598dSJonathan Doman             });
58249c53ac9SJohnathan Mantey     };
58349c53ac9SJohnathan Mantey 
58449c53ac9SJohnathan Mantey     // Get the Chassis Collection
58549c53ac9SJohnathan Mantey     crow::connections::systemBus->async_method_call(
58649c53ac9SJohnathan Mantey         respHandler, "xyz.openbmc_project.ObjectMapper",
58749c53ac9SJohnathan Mantey         "/xyz/openbmc_project/object_mapper",
58849c53ac9SJohnathan Mantey         "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
589271584abSEd Tanous         "/xyz/openbmc_project/inventory", 0, interfaces);
59055c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "getChassis exit";
59108777fb0SLewanczyk, Dawid }
59208777fb0SLewanczyk, Dawid 
59308777fb0SLewanczyk, Dawid /**
594de629b6eSShawn McCarney  * @brief Finds all DBus object paths that implement ObjectManager.
595de629b6eSShawn McCarney  *
596de629b6eSShawn McCarney  * Creates a mapping from the associated connection name to the object path.
597de629b6eSShawn McCarney  *
598de629b6eSShawn McCarney  * Finds the object paths asynchronously.  Invokes callback when information has
599de629b6eSShawn McCarney  * been obtained.
600de629b6eSShawn McCarney  *
601de629b6eSShawn McCarney  * The callback must have the following signature:
602de629b6eSShawn McCarney  *   @code
603fe04d49cSNan Zhou  *   callback(std::shared_ptr<std::map<std::string,std::string>> objectMgrPaths)
604de629b6eSShawn McCarney  *   @endcode
605de629b6eSShawn McCarney  *
60649c53ac9SJohnathan Mantey  * @param sensorsAsyncResp Pointer to object holding response data.
607de629b6eSShawn McCarney  * @param callback Callback to invoke when object paths obtained.
608de629b6eSShawn McCarney  */
609de629b6eSShawn McCarney template <typename Callback>
610b5a76932SEd Tanous void getObjectManagerPaths(
61181ce609eSEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
612de629b6eSShawn McCarney     Callback&& callback)
613de629b6eSShawn McCarney {
614de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getObjectManagerPaths enter";
615de629b6eSShawn McCarney     const std::array<std::string, 1> interfaces = {
616de629b6eSShawn McCarney         "org.freedesktop.DBus.ObjectManager"};
617de629b6eSShawn McCarney 
618de629b6eSShawn McCarney     // Response handler for GetSubTree DBus method
619002d39b4SEd Tanous     auto respHandler =
620002d39b4SEd Tanous         [callback{std::forward<Callback>(callback)}, sensorsAsyncResp](
621b9d36b47SEd Tanous             const boost::system::error_code ec,
622002d39b4SEd Tanous             const dbus::utility::MapperGetSubTreeResponse& subtree) {
623de629b6eSShawn McCarney         BMCWEB_LOG_DEBUG << "getObjectManagerPaths respHandler enter";
624de629b6eSShawn McCarney         if (ec)
625de629b6eSShawn McCarney         {
6268d1b46d7Szhanghch05             messages::internalError(sensorsAsyncResp->asyncResp->res);
627de629b6eSShawn McCarney             BMCWEB_LOG_ERROR << "getObjectManagerPaths respHandler: DBus error "
628de629b6eSShawn McCarney                              << ec;
629de629b6eSShawn McCarney             return;
630de629b6eSShawn McCarney         }
631de629b6eSShawn McCarney 
632de629b6eSShawn McCarney         // Loop over returned object paths
633fe04d49cSNan Zhou         std::shared_ptr<std::map<std::string, std::string>> objectMgrPaths =
634fe04d49cSNan Zhou             std::make_shared<std::map<std::string, std::string>>();
635de629b6eSShawn McCarney         for (const std::pair<
636de629b6eSShawn McCarney                  std::string,
637de629b6eSShawn McCarney                  std::vector<std::pair<std::string, std::vector<std::string>>>>&
638de629b6eSShawn McCarney                  object : subtree)
639de629b6eSShawn McCarney         {
640de629b6eSShawn McCarney             // Loop over connections for current object path
641de629b6eSShawn McCarney             const std::string& objectPath = object.first;
642de629b6eSShawn McCarney             for (const std::pair<std::string, std::vector<std::string>>&
643de629b6eSShawn McCarney                      objData : object.second)
644de629b6eSShawn McCarney             {
645de629b6eSShawn McCarney                 // Add mapping from connection to object path
646de629b6eSShawn McCarney                 const std::string& connection = objData.first;
6478fb49dd6SShawn McCarney                 (*objectMgrPaths)[connection] = objectPath;
648de629b6eSShawn McCarney                 BMCWEB_LOG_DEBUG << "Added mapping " << connection << " -> "
649de629b6eSShawn McCarney                                  << objectPath;
650de629b6eSShawn McCarney             }
651de629b6eSShawn McCarney         }
6528fb49dd6SShawn McCarney         callback(objectMgrPaths);
653de629b6eSShawn McCarney         BMCWEB_LOG_DEBUG << "getObjectManagerPaths respHandler exit";
654de629b6eSShawn McCarney     };
655de629b6eSShawn McCarney 
656de629b6eSShawn McCarney     // Query mapper for all DBus object paths that implement ObjectManager
657de629b6eSShawn McCarney     crow::connections::systemBus->async_method_call(
658de629b6eSShawn McCarney         std::move(respHandler), "xyz.openbmc_project.ObjectMapper",
659de629b6eSShawn McCarney         "/xyz/openbmc_project/object_mapper",
660271584abSEd Tanous         "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0, interfaces);
661de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getObjectManagerPaths exit";
662de629b6eSShawn McCarney }
663de629b6eSShawn McCarney 
664de629b6eSShawn McCarney /**
665adc4f0dbSShawn McCarney  * @brief Returns the Redfish State value for the specified inventory item.
666adc4f0dbSShawn McCarney  * @param inventoryItem D-Bus inventory item associated with a sensor.
667adc4f0dbSShawn McCarney  * @return State value for inventory item.
66834dd179eSJames Feist  */
66923a21a1cSEd Tanous inline std::string getState(const InventoryItem* inventoryItem)
670adc4f0dbSShawn McCarney {
671adc4f0dbSShawn McCarney     if ((inventoryItem != nullptr) && !(inventoryItem->isPresent))
672adc4f0dbSShawn McCarney     {
673adc4f0dbSShawn McCarney         return "Absent";
674adc4f0dbSShawn McCarney     }
67534dd179eSJames Feist 
676adc4f0dbSShawn McCarney     return "Enabled";
677adc4f0dbSShawn McCarney }
678adc4f0dbSShawn McCarney 
679adc4f0dbSShawn McCarney /**
680adc4f0dbSShawn McCarney  * @brief Returns the Redfish Health value for the specified sensor.
681adc4f0dbSShawn McCarney  * @param sensorJson Sensor JSON object.
6821d7c0054SEd Tanous  * @param valuesDict Map of all sensor DBus values.
683adc4f0dbSShawn McCarney  * @param inventoryItem D-Bus inventory item associated with the sensor.  Will
684adc4f0dbSShawn McCarney  * be nullptr if no associated inventory item was found.
685adc4f0dbSShawn McCarney  * @return Health value for sensor.
686adc4f0dbSShawn McCarney  */
6871d7c0054SEd Tanous inline std::string getHealth(nlohmann::json& sensorJson,
6881d7c0054SEd Tanous                              const dbus::utility::DBusPropertiesMap& valuesDict,
689adc4f0dbSShawn McCarney                              const InventoryItem* inventoryItem)
69034dd179eSJames Feist {
691adc4f0dbSShawn McCarney     // Get current health value (if any) in the sensor JSON object.  Some JSON
692adc4f0dbSShawn McCarney     // objects contain multiple sensors (such as PowerSupplies).  We want to set
693adc4f0dbSShawn McCarney     // the overall health to be the most severe of any of the sensors.
694adc4f0dbSShawn McCarney     std::string currentHealth;
695adc4f0dbSShawn McCarney     auto statusIt = sensorJson.find("Status");
696adc4f0dbSShawn McCarney     if (statusIt != sensorJson.end())
697adc4f0dbSShawn McCarney     {
698adc4f0dbSShawn McCarney         auto healthIt = statusIt->find("Health");
699adc4f0dbSShawn McCarney         if (healthIt != statusIt->end())
700adc4f0dbSShawn McCarney         {
701adc4f0dbSShawn McCarney             std::string* health = healthIt->get_ptr<std::string*>();
702adc4f0dbSShawn McCarney             if (health != nullptr)
703adc4f0dbSShawn McCarney             {
704adc4f0dbSShawn McCarney                 currentHealth = *health;
705adc4f0dbSShawn McCarney             }
706adc4f0dbSShawn McCarney         }
707adc4f0dbSShawn McCarney     }
708adc4f0dbSShawn McCarney 
709adc4f0dbSShawn McCarney     // If current health in JSON object is already Critical, return that.  This
710adc4f0dbSShawn McCarney     // should override the sensor health, which might be less severe.
711adc4f0dbSShawn McCarney     if (currentHealth == "Critical")
712adc4f0dbSShawn McCarney     {
713adc4f0dbSShawn McCarney         return "Critical";
714adc4f0dbSShawn McCarney     }
715adc4f0dbSShawn McCarney 
716*c1343bf6SKrzysztof Grobelny     const bool* criticalAlarmHigh = nullptr;
717*c1343bf6SKrzysztof Grobelny     const bool* criticalAlarmLow = nullptr;
718*c1343bf6SKrzysztof Grobelny     const bool* warningAlarmHigh = nullptr;
719*c1343bf6SKrzysztof Grobelny     const bool* warningAlarmLow = nullptr;
720711ac7a9SEd Tanous 
721*c1343bf6SKrzysztof Grobelny     const bool success = sdbusplus::unpackPropertiesNoThrow(
722*c1343bf6SKrzysztof Grobelny         dbus_utils::UnpackErrorPrinter(), valuesDict, "CriticalAlarmHigh",
723*c1343bf6SKrzysztof Grobelny         criticalAlarmHigh, "CriticalAlarmLow", criticalAlarmLow,
724*c1343bf6SKrzysztof Grobelny         "WarningAlarmHigh", warningAlarmHigh, "WarningAlarmLow",
725*c1343bf6SKrzysztof Grobelny         warningAlarmLow);
726*c1343bf6SKrzysztof Grobelny 
727*c1343bf6SKrzysztof Grobelny     if (success)
72834dd179eSJames Feist     {
729*c1343bf6SKrzysztof Grobelny         // Check if sensor has critical threshold alarm
730*c1343bf6SKrzysztof Grobelny         if ((criticalAlarmHigh != nullptr && *criticalAlarmHigh) ||
731*c1343bf6SKrzysztof Grobelny             (criticalAlarmLow != nullptr && *criticalAlarmLow))
73234dd179eSJames Feist         {
73334dd179eSJames Feist             return "Critical";
73434dd179eSJames Feist         }
73534dd179eSJames Feist     }
73634dd179eSJames Feist 
737adc4f0dbSShawn McCarney     // Check if associated inventory item is not functional
738adc4f0dbSShawn McCarney     if ((inventoryItem != nullptr) && !(inventoryItem->isFunctional))
739adc4f0dbSShawn McCarney     {
740adc4f0dbSShawn McCarney         return "Critical";
741adc4f0dbSShawn McCarney     }
742adc4f0dbSShawn McCarney 
743adc4f0dbSShawn McCarney     // If current health in JSON object is already Warning, return that. This
744adc4f0dbSShawn McCarney     // should override the sensor status, which might be less severe.
745adc4f0dbSShawn McCarney     if (currentHealth == "Warning")
746adc4f0dbSShawn McCarney     {
747adc4f0dbSShawn McCarney         return "Warning";
748adc4f0dbSShawn McCarney     }
749adc4f0dbSShawn McCarney 
750*c1343bf6SKrzysztof Grobelny     if (success)
751*c1343bf6SKrzysztof Grobelny     {
752adc4f0dbSShawn McCarney         // Check if sensor has warning threshold alarm
753*c1343bf6SKrzysztof Grobelny         if ((warningAlarmHigh != nullptr && *warningAlarmHigh) ||
754*c1343bf6SKrzysztof Grobelny             (warningAlarmLow != nullptr && *warningAlarmLow))
75534dd179eSJames Feist         {
756ebe4d91eSEd Tanous             return "Warning";
75734dd179eSJames Feist         }
75834dd179eSJames Feist     }
759adc4f0dbSShawn McCarney 
76034dd179eSJames Feist     return "OK";
76134dd179eSJames Feist }
76234dd179eSJames Feist 
76323a21a1cSEd Tanous inline void setLedState(nlohmann::json& sensorJson,
764d500549bSAnthony Wilson                         const InventoryItem* inventoryItem)
765d500549bSAnthony Wilson {
766d500549bSAnthony Wilson     if (inventoryItem != nullptr && !inventoryItem->ledObjectPath.empty())
767d500549bSAnthony Wilson     {
768d500549bSAnthony Wilson         switch (inventoryItem->ledState)
769d500549bSAnthony Wilson         {
770d500549bSAnthony Wilson             case LedState::OFF:
771d500549bSAnthony Wilson                 sensorJson["IndicatorLED"] = "Off";
772d500549bSAnthony Wilson                 break;
773d500549bSAnthony Wilson             case LedState::ON:
774d500549bSAnthony Wilson                 sensorJson["IndicatorLED"] = "Lit";
775d500549bSAnthony Wilson                 break;
776d500549bSAnthony Wilson             case LedState::BLINK:
777d500549bSAnthony Wilson                 sensorJson["IndicatorLED"] = "Blinking";
778d500549bSAnthony Wilson                 break;
77923a21a1cSEd Tanous             case LedState::UNKNOWN:
780d500549bSAnthony Wilson                 break;
781d500549bSAnthony Wilson         }
782d500549bSAnthony Wilson     }
783d500549bSAnthony Wilson }
784d500549bSAnthony Wilson 
78534dd179eSJames Feist /**
78608777fb0SLewanczyk, Dawid  * @brief Builds a json sensor representation of a sensor.
78708777fb0SLewanczyk, Dawid  * @param sensorName  The name of the sensor to be built
788274fad5aSGunnar Mills  * @param sensorType  The type (temperature, fan_tach, etc) of the sensor to
78908777fb0SLewanczyk, Dawid  * build
7901d7c0054SEd Tanous  * @param chassisSubNode The subnode (thermal, sensor, ect) of the sensor
7911d7c0054SEd Tanous  * @param propertiesDict A dictionary of the properties to build the sensor
7921d7c0054SEd Tanous  * from.
7931d7c0054SEd Tanous  * @param sensorJson  The json object to fill
794adc4f0dbSShawn McCarney  * @param inventoryItem D-Bus inventory item associated with the sensor.  Will
795adc4f0dbSShawn McCarney  * be nullptr if no associated inventory item was found.
79608777fb0SLewanczyk, Dawid  */
7971d7c0054SEd Tanous inline void objectPropertiesToJson(
7981d7c0054SEd Tanous     std::string_view sensorName, std::string_view sensorType,
7991d7c0054SEd Tanous     std::string_view chassisSubNode,
8001d7c0054SEd Tanous     const dbus::utility::DBusPropertiesMap& propertiesDict,
80181ce609eSEd Tanous     nlohmann::json& sensorJson, InventoryItem* inventoryItem)
8021abe55efSEd Tanous {
80308777fb0SLewanczyk, Dawid     // Assume values exist as is (10^0 == 1) if no scale exists
80408777fb0SLewanczyk, Dawid     int64_t scaleMultiplier = 0;
805*c1343bf6SKrzysztof Grobelny 
806*c1343bf6SKrzysztof Grobelny     const int64_t* scale = nullptr;
807*c1343bf6SKrzysztof Grobelny 
808*c1343bf6SKrzysztof Grobelny     const bool success = sdbusplus::unpackPropertiesNoThrow(
809*c1343bf6SKrzysztof Grobelny         dbus_utils::UnpackErrorPrinter(), propertiesDict, "Scale", scale);
810*c1343bf6SKrzysztof Grobelny 
811*c1343bf6SKrzysztof Grobelny     if (success && scale != nullptr)
812711ac7a9SEd Tanous     {
813*c1343bf6SKrzysztof Grobelny         scaleMultiplier = *scale;
814711ac7a9SEd Tanous     }
81508777fb0SLewanczyk, Dawid 
8161d7c0054SEd Tanous     if (chassisSubNode == sensors::node::sensors)
817adc4f0dbSShawn McCarney     {
818c1d019a6SEd Tanous         std::string subNodeEscaped(chassisSubNode);
819c1d019a6SEd Tanous         subNodeEscaped.erase(
820c1d019a6SEd Tanous             std::remove(subNodeEscaped.begin(), subNodeEscaped.end(), '_'),
821c1d019a6SEd Tanous             subNodeEscaped.end());
822c1d019a6SEd Tanous 
823c1d019a6SEd Tanous         // For sensors in SensorCollection we set Id instead of MemberId,
824c1d019a6SEd Tanous         // including power sensors.
825c1d019a6SEd Tanous         subNodeEscaped += '_';
826c1d019a6SEd Tanous         subNodeEscaped += sensorName;
827c1d019a6SEd Tanous         sensorJson["Id"] = std::move(subNodeEscaped);
828c1d019a6SEd Tanous 
8291d7c0054SEd Tanous         std::string sensorNameEs(sensorName);
8301d7c0054SEd Tanous         std::replace(sensorNameEs.begin(), sensorNameEs.end(), '_', ' ');
8311d7c0054SEd Tanous         sensorJson["Name"] = std::move(sensorNameEs);
83295a3ecadSAnthony Wilson     }
83395a3ecadSAnthony Wilson     else if (sensorType != "power")
83495a3ecadSAnthony Wilson     {
83595a3ecadSAnthony Wilson         // Set MemberId and Name for non-power sensors.  For PowerSupplies and
83695a3ecadSAnthony Wilson         // PowerControl, those properties have more general values because
83795a3ecadSAnthony Wilson         // multiple sensors can be stored in the same JSON object.
83881ce609eSEd Tanous         sensorJson["MemberId"] = sensorName;
8391d7c0054SEd Tanous         std::string sensorNameEs(sensorName);
8401d7c0054SEd Tanous         std::replace(sensorNameEs.begin(), sensorNameEs.end(), '_', ' ');
8411d7c0054SEd Tanous         sensorJson["Name"] = std::move(sensorNameEs);
842adc4f0dbSShawn McCarney     }
843e742b6ccSEd Tanous 
84481ce609eSEd Tanous     sensorJson["Status"]["State"] = getState(inventoryItem);
84581ce609eSEd Tanous     sensorJson["Status"]["Health"] =
8461d7c0054SEd Tanous         getHealth(sensorJson, propertiesDict, inventoryItem);
84708777fb0SLewanczyk, Dawid 
84808777fb0SLewanczyk, Dawid     // Parameter to set to override the type we get from dbus, and force it to
84908777fb0SLewanczyk, Dawid     // int, regardless of what is available.  This is used for schemas like fan,
85008777fb0SLewanczyk, Dawid     // that require integers, not floats.
85108777fb0SLewanczyk, Dawid     bool forceToInt = false;
85208777fb0SLewanczyk, Dawid 
8533929aca1SAnthony Wilson     nlohmann::json::json_pointer unit("/Reading");
8541d7c0054SEd Tanous     if (chassisSubNode == sensors::node::sensors)
85595a3ecadSAnthony Wilson     {
8562a4ba195SShounak Mitra         sensorJson["@odata.type"] = "#Sensor.v1_2_0.Sensor";
857c2bf7f99SWludzik, Jozef 
8581d7c0054SEd Tanous         std::string_view readingType = sensors::toReadingType(sensorType);
859c2bf7f99SWludzik, Jozef         if (readingType.empty())
86095a3ecadSAnthony Wilson         {
861c2bf7f99SWludzik, Jozef             BMCWEB_LOG_ERROR << "Redfish cannot map reading type for "
862c2bf7f99SWludzik, Jozef                              << sensorType;
86395a3ecadSAnthony Wilson         }
864c2bf7f99SWludzik, Jozef         else
86595a3ecadSAnthony Wilson         {
866c2bf7f99SWludzik, Jozef             sensorJson["ReadingType"] = readingType;
86795a3ecadSAnthony Wilson         }
868c2bf7f99SWludzik, Jozef 
8691d7c0054SEd Tanous         std::string_view readingUnits = sensors::toReadingUnits(sensorType);
870c2bf7f99SWludzik, Jozef         if (readingUnits.empty())
871f8ede15eSAdrian Ambrożewicz         {
872c2bf7f99SWludzik, Jozef             BMCWEB_LOG_ERROR << "Redfish cannot map reading unit for "
873c2bf7f99SWludzik, Jozef                              << sensorType;
874c2bf7f99SWludzik, Jozef         }
875c2bf7f99SWludzik, Jozef         else
876c2bf7f99SWludzik, Jozef         {
877c2bf7f99SWludzik, Jozef             sensorJson["ReadingUnits"] = readingUnits;
878f8ede15eSAdrian Ambrożewicz         }
87995a3ecadSAnthony Wilson     }
88095a3ecadSAnthony Wilson     else if (sensorType == "temperature")
8811abe55efSEd Tanous     {
8823929aca1SAnthony Wilson         unit = "/ReadingCelsius"_json_pointer;
88381ce609eSEd Tanous         sensorJson["@odata.type"] = "#Thermal.v1_3_0.Temperature";
88408777fb0SLewanczyk, Dawid         // TODO(ed) Documentation says that path should be type fan_tach,
88508777fb0SLewanczyk, Dawid         // implementation seems to implement fan
8861abe55efSEd Tanous     }
8871abe55efSEd Tanous     else if (sensorType == "fan" || sensorType == "fan_tach")
8881abe55efSEd Tanous     {
8893929aca1SAnthony Wilson         unit = "/Reading"_json_pointer;
89081ce609eSEd Tanous         sensorJson["ReadingUnits"] = "RPM";
89181ce609eSEd Tanous         sensorJson["@odata.type"] = "#Thermal.v1_3_0.Fan";
89281ce609eSEd Tanous         setLedState(sensorJson, inventoryItem);
89308777fb0SLewanczyk, Dawid         forceToInt = true;
8941abe55efSEd Tanous     }
8956f6d0d32SEd Tanous     else if (sensorType == "fan_pwm")
8966f6d0d32SEd Tanous     {
8973929aca1SAnthony Wilson         unit = "/Reading"_json_pointer;
89881ce609eSEd Tanous         sensorJson["ReadingUnits"] = "Percent";
89981ce609eSEd Tanous         sensorJson["@odata.type"] = "#Thermal.v1_3_0.Fan";
90081ce609eSEd Tanous         setLedState(sensorJson, inventoryItem);
9016f6d0d32SEd Tanous         forceToInt = true;
9026f6d0d32SEd Tanous     }
9031abe55efSEd Tanous     else if (sensorType == "voltage")
9041abe55efSEd Tanous     {
9053929aca1SAnthony Wilson         unit = "/ReadingVolts"_json_pointer;
90681ce609eSEd Tanous         sensorJson["@odata.type"] = "#Power.v1_0_0.Voltage";
9071abe55efSEd Tanous     }
9082474adfaSEd Tanous     else if (sensorType == "power")
9092474adfaSEd Tanous     {
9101d7c0054SEd Tanous         if (boost::iequals(sensorName, "total_power"))
911028f7ebcSEddie James         {
91281ce609eSEd Tanous             sensorJson["@odata.type"] = "#Power.v1_0_0.PowerControl";
9137ab06f49SGunnar Mills             // Put multiple "sensors" into a single PowerControl, so have
9147ab06f49SGunnar Mills             // generic names for MemberId and Name. Follows Redfish mockup.
91581ce609eSEd Tanous             sensorJson["MemberId"] = "0";
91681ce609eSEd Tanous             sensorJson["Name"] = "Chassis Power Control";
9173929aca1SAnthony Wilson             unit = "/PowerConsumedWatts"_json_pointer;
918028f7ebcSEddie James         }
9191d7c0054SEd Tanous         else if (boost::ifind_first(sensorName, "input").empty())
92049c53ac9SJohnathan Mantey         {
9213929aca1SAnthony Wilson             unit = "/PowerInputWatts"_json_pointer;
92249c53ac9SJohnathan Mantey         }
92349c53ac9SJohnathan Mantey         else
92449c53ac9SJohnathan Mantey         {
9253929aca1SAnthony Wilson             unit = "/PowerOutputWatts"_json_pointer;
92649c53ac9SJohnathan Mantey         }
9272474adfaSEd Tanous     }
9281abe55efSEd Tanous     else
9291abe55efSEd Tanous     {
93055c7b7a2SEd Tanous         BMCWEB_LOG_ERROR << "Redfish cannot map object type for " << sensorName;
93108777fb0SLewanczyk, Dawid         return;
93208777fb0SLewanczyk, Dawid     }
93308777fb0SLewanczyk, Dawid     // Map of dbus interface name, dbus property name and redfish property_name
9343929aca1SAnthony Wilson     std::vector<
9353929aca1SAnthony Wilson         std::tuple<const char*, const char*, nlohmann::json::json_pointer>>
9363929aca1SAnthony Wilson         properties;
93708777fb0SLewanczyk, Dawid     properties.reserve(7);
93808777fb0SLewanczyk, Dawid 
93908777fb0SLewanczyk, Dawid     properties.emplace_back("xyz.openbmc_project.Sensor.Value", "Value", unit);
940de629b6eSShawn McCarney 
9411d7c0054SEd Tanous     if (chassisSubNode == sensors::node::sensors)
9423929aca1SAnthony Wilson     {
9433929aca1SAnthony Wilson         properties.emplace_back(
9443929aca1SAnthony Wilson             "xyz.openbmc_project.Sensor.Threshold.Warning", "WarningHigh",
9453929aca1SAnthony Wilson             "/Thresholds/UpperCaution/Reading"_json_pointer);
9463929aca1SAnthony Wilson         properties.emplace_back(
9473929aca1SAnthony Wilson             "xyz.openbmc_project.Sensor.Threshold.Warning", "WarningLow",
9483929aca1SAnthony Wilson             "/Thresholds/LowerCaution/Reading"_json_pointer);
9493929aca1SAnthony Wilson         properties.emplace_back(
9503929aca1SAnthony Wilson             "xyz.openbmc_project.Sensor.Threshold.Critical", "CriticalHigh",
9513929aca1SAnthony Wilson             "/Thresholds/UpperCritical/Reading"_json_pointer);
9523929aca1SAnthony Wilson         properties.emplace_back(
9533929aca1SAnthony Wilson             "xyz.openbmc_project.Sensor.Threshold.Critical", "CriticalLow",
9543929aca1SAnthony Wilson             "/Thresholds/LowerCritical/Reading"_json_pointer);
9553929aca1SAnthony Wilson     }
9563929aca1SAnthony Wilson     else if (sensorType != "power")
957de629b6eSShawn McCarney     {
95808777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Warning",
9593929aca1SAnthony Wilson                                 "WarningHigh",
9603929aca1SAnthony Wilson                                 "/UpperThresholdNonCritical"_json_pointer);
96108777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Warning",
9623929aca1SAnthony Wilson                                 "WarningLow",
9633929aca1SAnthony Wilson                                 "/LowerThresholdNonCritical"_json_pointer);
96408777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Critical",
9653929aca1SAnthony Wilson                                 "CriticalHigh",
9663929aca1SAnthony Wilson                                 "/UpperThresholdCritical"_json_pointer);
96708777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Critical",
9683929aca1SAnthony Wilson                                 "CriticalLow",
9693929aca1SAnthony Wilson                                 "/LowerThresholdCritical"_json_pointer);
970de629b6eSShawn McCarney     }
97108777fb0SLewanczyk, Dawid 
9722474adfaSEd Tanous     // TODO Need to get UpperThresholdFatal and LowerThresholdFatal
9732474adfaSEd Tanous 
9741d7c0054SEd Tanous     if (chassisSubNode == sensors::node::sensors)
97595a3ecadSAnthony Wilson     {
97695a3ecadSAnthony Wilson         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MinValue",
9773929aca1SAnthony Wilson                                 "/ReadingRangeMin"_json_pointer);
97895a3ecadSAnthony Wilson         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MaxValue",
9793929aca1SAnthony Wilson                                 "/ReadingRangeMax"_json_pointer);
98095a3ecadSAnthony Wilson     }
98195a3ecadSAnthony Wilson     else if (sensorType == "temperature")
9821abe55efSEd Tanous     {
98308777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MinValue",
9843929aca1SAnthony Wilson                                 "/MinReadingRangeTemp"_json_pointer);
98508777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MaxValue",
9863929aca1SAnthony Wilson                                 "/MaxReadingRangeTemp"_json_pointer);
9871abe55efSEd Tanous     }
988adc4f0dbSShawn McCarney     else if (sensorType != "power")
9891abe55efSEd Tanous     {
99008777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MinValue",
9913929aca1SAnthony Wilson                                 "/MinReadingRange"_json_pointer);
99208777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MaxValue",
9933929aca1SAnthony Wilson                                 "/MaxReadingRange"_json_pointer);
99408777fb0SLewanczyk, Dawid     }
99508777fb0SLewanczyk, Dawid 
9963929aca1SAnthony Wilson     for (const std::tuple<const char*, const char*,
9973929aca1SAnthony Wilson                           nlohmann::json::json_pointer>& p : properties)
9981abe55efSEd Tanous     {
9991d7c0054SEd Tanous         for (const auto& [valueName, valueVariant] : propertiesDict)
1000711ac7a9SEd Tanous         {
1001711ac7a9SEd Tanous             if (valueName != std::get<1>(p))
1002711ac7a9SEd Tanous             {
1003711ac7a9SEd Tanous                 continue;
1004711ac7a9SEd Tanous             }
10053929aca1SAnthony Wilson 
10063929aca1SAnthony Wilson             // The property we want to set may be nested json, so use
10073929aca1SAnthony Wilson             // a json_pointer for easy indexing into the json structure.
10083929aca1SAnthony Wilson             const nlohmann::json::json_pointer& key = std::get<2>(p);
10093929aca1SAnthony Wilson 
101008777fb0SLewanczyk, Dawid             // Attempt to pull the int64 directly
1011abf2add6SEd Tanous             const int64_t* int64Value = std::get_if<int64_t>(&valueVariant);
101208777fb0SLewanczyk, Dawid 
1013abf2add6SEd Tanous             const double* doubleValue = std::get_if<double>(&valueVariant);
1014028f7ebcSEddie James             const uint32_t* uValue = std::get_if<uint32_t>(&valueVariant);
10156f6d0d32SEd Tanous             double temp = 0.0;
10166f6d0d32SEd Tanous             if (int64Value != nullptr)
10171abe55efSEd Tanous             {
1018271584abSEd Tanous                 temp = static_cast<double>(*int64Value);
10196f6d0d32SEd Tanous             }
10206f6d0d32SEd Tanous             else if (doubleValue != nullptr)
10211abe55efSEd Tanous             {
10226f6d0d32SEd Tanous                 temp = *doubleValue;
10231abe55efSEd Tanous             }
1024028f7ebcSEddie James             else if (uValue != nullptr)
1025028f7ebcSEddie James             {
1026028f7ebcSEddie James                 temp = *uValue;
1027028f7ebcSEddie James             }
10281abe55efSEd Tanous             else
10291abe55efSEd Tanous             {
10306f6d0d32SEd Tanous                 BMCWEB_LOG_ERROR
10316f6d0d32SEd Tanous                     << "Got value interface that wasn't int or double";
10326f6d0d32SEd Tanous                 continue;
103308777fb0SLewanczyk, Dawid             }
10346f6d0d32SEd Tanous             temp = temp * std::pow(10, scaleMultiplier);
10356f6d0d32SEd Tanous             if (forceToInt)
10366f6d0d32SEd Tanous             {
103781ce609eSEd Tanous                 sensorJson[key] = static_cast<int64_t>(temp);
10386f6d0d32SEd Tanous             }
10396f6d0d32SEd Tanous             else
10406f6d0d32SEd Tanous             {
104181ce609eSEd Tanous                 sensorJson[key] = temp;
104208777fb0SLewanczyk, Dawid             }
104308777fb0SLewanczyk, Dawid         }
104408777fb0SLewanczyk, Dawid     }
104508777fb0SLewanczyk, Dawid }
104608777fb0SLewanczyk, Dawid 
10471d7c0054SEd Tanous /**
10481d7c0054SEd Tanous  * @brief Builds a json sensor representation of a sensor.
10491d7c0054SEd Tanous  * @param sensorName  The name of the sensor to be built
10501d7c0054SEd Tanous  * @param sensorType  The type (temperature, fan_tach, etc) of the sensor to
10511d7c0054SEd Tanous  * build
10521d7c0054SEd Tanous  * @param chassisSubNode The subnode (thermal, sensor, ect) of the sensor
10531d7c0054SEd Tanous  * @param interfacesDict  A dictionary of the interfaces and properties of said
10541d7c0054SEd Tanous  * interfaces to be built from
10551d7c0054SEd Tanous  * @param sensorJson  The json object to fill
10561d7c0054SEd Tanous  * @param inventoryItem D-Bus inventory item associated with the sensor.  Will
10571d7c0054SEd Tanous  * be nullptr if no associated inventory item was found.
10581d7c0054SEd Tanous  */
10591d7c0054SEd Tanous inline void objectInterfacesToJson(
10601d7c0054SEd Tanous     const std::string& sensorName, const std::string& sensorType,
10611d7c0054SEd Tanous     const std::string& chassisSubNode,
10621d7c0054SEd Tanous     const dbus::utility::DBusInteracesMap& interfacesDict,
10631d7c0054SEd Tanous     nlohmann::json& sensorJson, InventoryItem* inventoryItem)
10641d7c0054SEd Tanous {
10651d7c0054SEd Tanous 
10661d7c0054SEd Tanous     for (const auto& [interface, valuesDict] : interfacesDict)
10671d7c0054SEd Tanous     {
10681d7c0054SEd Tanous         objectPropertiesToJson(sensorName, sensorType, chassisSubNode,
10691d7c0054SEd Tanous                                valuesDict, sensorJson, inventoryItem);
10701d7c0054SEd Tanous     }
1071c1d019a6SEd Tanous     BMCWEB_LOG_DEBUG << "Added sensor " << sensorName;
10721d7c0054SEd Tanous }
10731d7c0054SEd Tanous 
1074b5a76932SEd Tanous inline void populateFanRedundancy(
1075b5a76932SEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp)
10768bd25ccdSJames Feist {
10778bd25ccdSJames Feist     crow::connections::systemBus->async_method_call(
1078b9d36b47SEd Tanous         [sensorsAsyncResp](
1079b9d36b47SEd Tanous             const boost::system::error_code ec,
1080b9d36b47SEd Tanous             const dbus::utility::MapperGetSubTreeResponse& resp) {
10818bd25ccdSJames Feist         if (ec)
10828bd25ccdSJames Feist         {
10838bd25ccdSJames Feist             return; // don't have to have this interface
10848bd25ccdSJames Feist         }
1085002d39b4SEd Tanous         for (const std::pair<
1086002d39b4SEd Tanous                  std::string,
1087002d39b4SEd Tanous                  std::vector<std::pair<std::string, std::vector<std::string>>>>&
1088e278c18fSEd Tanous                  pathPair : resp)
10898bd25ccdSJames Feist         {
1090e278c18fSEd Tanous             const std::string& path = pathPair.first;
1091002d39b4SEd Tanous             const std::vector<std::pair<std::string, std::vector<std::string>>>&
1092002d39b4SEd Tanous                 objDict = pathPair.second;
10938bd25ccdSJames Feist             if (objDict.empty())
10948bd25ccdSJames Feist             {
10958bd25ccdSJames Feist                 continue; // this should be impossible
10968bd25ccdSJames Feist             }
10978bd25ccdSJames Feist 
10988bd25ccdSJames Feist             const std::string& owner = objDict.begin()->first;
10991e1e598dSJonathan Doman             sdbusplus::asio::getProperty<std::vector<std::string>>(
11001e1e598dSJonathan Doman                 *crow::connections::systemBus,
11011e1e598dSJonathan Doman                 "xyz.openbmc_project.ObjectMapper", path + "/chassis",
11021e1e598dSJonathan Doman                 "xyz.openbmc_project.Association", "endpoints",
1103002d39b4SEd Tanous                 [path, owner,
1104002d39b4SEd Tanous                  sensorsAsyncResp](const boost::system::error_code e,
11051e1e598dSJonathan Doman                                    const std::vector<std::string>& endpoints) {
1106271584abSEd Tanous                 if (e)
11078bd25ccdSJames Feist                 {
11088bd25ccdSJames Feist                     return; // if they don't have an association we
11098bd25ccdSJames Feist                             // can't tell what chassis is
11108bd25ccdSJames Feist                 }
1111002d39b4SEd Tanous                 auto found =
1112002d39b4SEd Tanous                     std::find_if(endpoints.begin(), endpoints.end(),
11138bd25ccdSJames Feist                                  [sensorsAsyncResp](const std::string& entry) {
1114002d39b4SEd Tanous                     return entry.find(sensorsAsyncResp->chassisId) !=
11158bd25ccdSJames Feist                            std::string::npos;
11168bd25ccdSJames Feist                     });
11178bd25ccdSJames Feist 
11181e1e598dSJonathan Doman                 if (found == endpoints.end())
11198bd25ccdSJames Feist                 {
11208bd25ccdSJames Feist                     return;
11218bd25ccdSJames Feist                 }
112286d89ed7SKrzysztof Grobelny                 sdbusplus::asio::getAllProperties(
112386d89ed7SKrzysztof Grobelny                     *crow::connections::systemBus, owner, path,
112486d89ed7SKrzysztof Grobelny                     "xyz.openbmc_project.Control.FanRedundancy",
11258bd25ccdSJames Feist                     [path, sensorsAsyncResp](
1126271584abSEd Tanous                         const boost::system::error_code& err,
112786d89ed7SKrzysztof Grobelny                         const dbus::utility::DBusPropertiesMap& ret) {
1128271584abSEd Tanous                     if (err)
11298bd25ccdSJames Feist                     {
11308bd25ccdSJames Feist                         return; // don't have to have this
11318bd25ccdSJames Feist                                 // interface
11328bd25ccdSJames Feist                     }
11338bd25ccdSJames Feist 
113486d89ed7SKrzysztof Grobelny                     const uint8_t* allowedFailures = nullptr;
113586d89ed7SKrzysztof Grobelny                     const std::vector<std::string>* collection = nullptr;
113686d89ed7SKrzysztof Grobelny                     const std::string* status = nullptr;
113786d89ed7SKrzysztof Grobelny 
113886d89ed7SKrzysztof Grobelny                     const bool success = sdbusplus::unpackPropertiesNoThrow(
113986d89ed7SKrzysztof Grobelny                         dbus_utils::UnpackErrorPrinter(), ret,
114086d89ed7SKrzysztof Grobelny                         "AllowedFailures", allowedFailures, "Collection",
114186d89ed7SKrzysztof Grobelny                         collection, "Status", status);
114286d89ed7SKrzysztof Grobelny 
114386d89ed7SKrzysztof Grobelny                     if (!success)
114486d89ed7SKrzysztof Grobelny                     {
114586d89ed7SKrzysztof Grobelny                         messages::internalError(
114686d89ed7SKrzysztof Grobelny                             sensorsAsyncResp->asyncResp->res);
114786d89ed7SKrzysztof Grobelny                         return;
114886d89ed7SKrzysztof Grobelny                     }
114986d89ed7SKrzysztof Grobelny 
115086d89ed7SKrzysztof Grobelny                     if (allowedFailures == nullptr || collection == nullptr ||
115186d89ed7SKrzysztof Grobelny                         status == nullptr)
11528bd25ccdSJames Feist                     {
1153002d39b4SEd Tanous                         BMCWEB_LOG_ERROR << "Invalid redundancy interface";
11548bd25ccdSJames Feist                         messages::internalError(
11558d1b46d7Szhanghch05                             sensorsAsyncResp->asyncResp->res);
11568bd25ccdSJames Feist                         return;
11578bd25ccdSJames Feist                     }
11588bd25ccdSJames Feist 
1159002d39b4SEd Tanous                     sdbusplus::message::object_path objectPath(path);
116028aa8de5SGeorge Liu                     std::string name = objectPath.filename();
116128aa8de5SGeorge Liu                     if (name.empty())
11628bd25ccdSJames Feist                     {
11638bd25ccdSJames Feist                         // this should be impossible
11648bd25ccdSJames Feist                         messages::internalError(
11658d1b46d7Szhanghch05                             sensorsAsyncResp->asyncResp->res);
11668bd25ccdSJames Feist                         return;
11678bd25ccdSJames Feist                     }
1168002d39b4SEd Tanous                     std::replace(name.begin(), name.end(), '_', ' ');
11698bd25ccdSJames Feist 
11708bd25ccdSJames Feist                     std::string health;
11718bd25ccdSJames Feist 
117211ba3979SEd Tanous                     if (status->ends_with("Full"))
11738bd25ccdSJames Feist                     {
11748bd25ccdSJames Feist                         health = "OK";
11758bd25ccdSJames Feist                     }
117611ba3979SEd Tanous                     else if (status->ends_with("Degraded"))
11778bd25ccdSJames Feist                     {
11788bd25ccdSJames Feist                         health = "Warning";
11798bd25ccdSJames Feist                     }
11808bd25ccdSJames Feist                     else
11818bd25ccdSJames Feist                     {
11828bd25ccdSJames Feist                         health = "Critical";
11838bd25ccdSJames Feist                     }
11841476687dSEd Tanous                     nlohmann::json::array_t redfishCollection;
11858bd25ccdSJames Feist                     const auto& fanRedfish =
1186002d39b4SEd Tanous                         sensorsAsyncResp->asyncResp->res.jsonValue["Fans"];
11878bd25ccdSJames Feist                     for (const std::string& item : *collection)
11888bd25ccdSJames Feist                     {
11898a592810SEd Tanous                         sdbusplus::message::object_path itemPath(item);
11908a592810SEd Tanous                         std::string itemName = itemPath.filename();
119128aa8de5SGeorge Liu                         if (itemName.empty())
119228aa8de5SGeorge Liu                         {
119328aa8de5SGeorge Liu                             continue;
119428aa8de5SGeorge Liu                         }
11958bd25ccdSJames Feist                         /*
11968bd25ccdSJames Feist                         todo(ed): merge patch that fixes the names
11978bd25ccdSJames Feist                         std::replace(itemName.begin(),
11988bd25ccdSJames Feist                                      itemName.end(), '_', ' ');*/
1199002d39b4SEd Tanous                         auto schemaItem =
1200002d39b4SEd Tanous                             std::find_if(fanRedfish.begin(), fanRedfish.end(),
12018bd25ccdSJames Feist                                          [itemName](const nlohmann::json& fan) {
12028bd25ccdSJames Feist                             return fan["MemberId"] == itemName;
12038bd25ccdSJames Feist                             });
12048bd25ccdSJames Feist                         if (schemaItem != fanRedfish.end())
12058bd25ccdSJames Feist                         {
12068a592810SEd Tanous                             nlohmann::json::object_t collectionId;
12078a592810SEd Tanous                             collectionId["@odata.id"] =
12081476687dSEd Tanous                                 (*schemaItem)["@odata.id"];
12091476687dSEd Tanous                             redfishCollection.emplace_back(
12108a592810SEd Tanous                                 std::move(collectionId));
12118bd25ccdSJames Feist                         }
12128bd25ccdSJames Feist                         else
12138bd25ccdSJames Feist                         {
1214002d39b4SEd Tanous                             BMCWEB_LOG_ERROR << "failed to find fan in schema";
12158bd25ccdSJames Feist                             messages::internalError(
12168d1b46d7Szhanghch05                                 sensorsAsyncResp->asyncResp->res);
12178bd25ccdSJames Feist                             return;
12188bd25ccdSJames Feist                         }
12198bd25ccdSJames Feist                     }
12208bd25ccdSJames Feist 
12213e9e72ebSKuiying Wang                     size_t minNumNeeded =
122226f6976fSEd Tanous                         collection->empty()
122326f6976fSEd Tanous                             ? 0
122426f6976fSEd Tanous                             : collection->size() - *allowedFailures;
1225002d39b4SEd Tanous                     nlohmann::json& jResp = sensorsAsyncResp->asyncResp->res
12268bd25ccdSJames Feist                                                 .jsonValue["Redundancy"];
12271476687dSEd Tanous 
12281476687dSEd Tanous                     nlohmann::json::object_t redundancy;
12291476687dSEd Tanous                     redundancy["@odata.id"] =
1230002d39b4SEd Tanous                         "/redfish/v1/Chassis/" + sensorsAsyncResp->chassisId +
1231002d39b4SEd Tanous                         "/" + sensorsAsyncResp->chassisSubNode +
1232002d39b4SEd Tanous                         "#/Redundancy/" + std::to_string(jResp.size());
1233002d39b4SEd Tanous                     redundancy["@odata.type"] = "#Redundancy.v1_3_2.Redundancy";
12341476687dSEd Tanous                     redundancy["MinNumNeeded"] = minNumNeeded;
12351476687dSEd Tanous                     redundancy["MemberId"] = name;
12361476687dSEd Tanous                     redundancy["Mode"] = "N+m";
12371476687dSEd Tanous                     redundancy["Name"] = name;
12381476687dSEd Tanous                     redundancy["RedundancySet"] = redfishCollection;
12391476687dSEd Tanous                     redundancy["Status"]["Health"] = health;
12401476687dSEd Tanous                     redundancy["Status"]["State"] = "Enabled";
12411476687dSEd Tanous 
12421476687dSEd Tanous                     jResp.push_back(std::move(redundancy));
124386d89ed7SKrzysztof Grobelny                     });
12441e1e598dSJonathan Doman                 });
12458bd25ccdSJames Feist         }
12468bd25ccdSJames Feist         },
12478bd25ccdSJames Feist         "xyz.openbmc_project.ObjectMapper",
12488bd25ccdSJames Feist         "/xyz/openbmc_project/object_mapper",
12498bd25ccdSJames Feist         "xyz.openbmc_project.ObjectMapper", "GetSubTree",
12508bd25ccdSJames Feist         "/xyz/openbmc_project/control", 2,
12518bd25ccdSJames Feist         std::array<const char*, 1>{
12528bd25ccdSJames Feist             "xyz.openbmc_project.Control.FanRedundancy"});
12538bd25ccdSJames Feist }
12548bd25ccdSJames Feist 
1255b5a76932SEd Tanous inline void
125681ce609eSEd Tanous     sortJSONResponse(const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp)
125749c53ac9SJohnathan Mantey {
12588d1b46d7Szhanghch05     nlohmann::json& response = sensorsAsyncResp->asyncResp->res.jsonValue;
125949c53ac9SJohnathan Mantey     std::array<std::string, 2> sensorHeaders{"Temperatures", "Fans"};
126081ce609eSEd Tanous     if (sensorsAsyncResp->chassisSubNode == sensors::node::power)
126149c53ac9SJohnathan Mantey     {
126249c53ac9SJohnathan Mantey         sensorHeaders = {"Voltages", "PowerSupplies"};
126349c53ac9SJohnathan Mantey     }
126449c53ac9SJohnathan Mantey     for (const std::string& sensorGroup : sensorHeaders)
126549c53ac9SJohnathan Mantey     {
126649c53ac9SJohnathan Mantey         nlohmann::json::iterator entry = response.find(sensorGroup);
126749c53ac9SJohnathan Mantey         if (entry != response.end())
126849c53ac9SJohnathan Mantey         {
126949c53ac9SJohnathan Mantey             std::sort(entry->begin(), entry->end(),
127002cad96eSEd Tanous                       [](const nlohmann::json& c1, const nlohmann::json& c2) {
127149c53ac9SJohnathan Mantey                 return c1["Name"] < c2["Name"];
127249c53ac9SJohnathan Mantey             });
127349c53ac9SJohnathan Mantey 
127449c53ac9SJohnathan Mantey             // add the index counts to the end of each entry
127549c53ac9SJohnathan Mantey             size_t count = 0;
127649c53ac9SJohnathan Mantey             for (nlohmann::json& sensorJson : *entry)
127749c53ac9SJohnathan Mantey             {
127849c53ac9SJohnathan Mantey                 nlohmann::json::iterator odata = sensorJson.find("@odata.id");
127949c53ac9SJohnathan Mantey                 if (odata == sensorJson.end())
128049c53ac9SJohnathan Mantey                 {
128149c53ac9SJohnathan Mantey                     continue;
128249c53ac9SJohnathan Mantey                 }
128349c53ac9SJohnathan Mantey                 std::string* value = odata->get_ptr<std::string*>();
128449c53ac9SJohnathan Mantey                 if (value != nullptr)
128549c53ac9SJohnathan Mantey                 {
128649c53ac9SJohnathan Mantey                     *value += std::to_string(count);
128749c53ac9SJohnathan Mantey                     count++;
128881ce609eSEd Tanous                     sensorsAsyncResp->updateUri(sensorJson["Name"], *value);
128949c53ac9SJohnathan Mantey                 }
129049c53ac9SJohnathan Mantey             }
129149c53ac9SJohnathan Mantey         }
129249c53ac9SJohnathan Mantey     }
129349c53ac9SJohnathan Mantey }
129449c53ac9SJohnathan Mantey 
129508777fb0SLewanczyk, Dawid /**
1296adc4f0dbSShawn McCarney  * @brief Finds the inventory item with the specified object path.
1297adc4f0dbSShawn McCarney  * @param inventoryItems D-Bus inventory items associated with sensors.
1298adc4f0dbSShawn McCarney  * @param invItemObjPath D-Bus object path of inventory item.
1299adc4f0dbSShawn McCarney  * @return Inventory item within vector, or nullptr if no match found.
13008fb49dd6SShawn McCarney  */
130123a21a1cSEd Tanous inline InventoryItem* findInventoryItem(
1302b5a76932SEd Tanous     const std::shared_ptr<std::vector<InventoryItem>>& inventoryItems,
1303adc4f0dbSShawn McCarney     const std::string& invItemObjPath)
13048fb49dd6SShawn McCarney {
1305adc4f0dbSShawn McCarney     for (InventoryItem& inventoryItem : *inventoryItems)
13068fb49dd6SShawn McCarney     {
1307adc4f0dbSShawn McCarney         if (inventoryItem.objectPath == invItemObjPath)
13088fb49dd6SShawn McCarney         {
1309adc4f0dbSShawn McCarney             return &inventoryItem;
13108fb49dd6SShawn McCarney         }
13118fb49dd6SShawn McCarney     }
13128fb49dd6SShawn McCarney     return nullptr;
13138fb49dd6SShawn McCarney }
13148fb49dd6SShawn McCarney 
13158fb49dd6SShawn McCarney /**
1316adc4f0dbSShawn McCarney  * @brief Finds the inventory item associated with the specified sensor.
1317adc4f0dbSShawn McCarney  * @param inventoryItems D-Bus inventory items associated with sensors.
1318adc4f0dbSShawn McCarney  * @param sensorObjPath D-Bus object path of sensor.
1319adc4f0dbSShawn McCarney  * @return Inventory item within vector, or nullptr if no match found.
13208fb49dd6SShawn McCarney  */
132123a21a1cSEd Tanous inline InventoryItem* findInventoryItemForSensor(
1322b5a76932SEd Tanous     const std::shared_ptr<std::vector<InventoryItem>>& inventoryItems,
1323adc4f0dbSShawn McCarney     const std::string& sensorObjPath)
1324adc4f0dbSShawn McCarney {
1325adc4f0dbSShawn McCarney     for (InventoryItem& inventoryItem : *inventoryItems)
1326adc4f0dbSShawn McCarney     {
1327adc4f0dbSShawn McCarney         if (inventoryItem.sensors.count(sensorObjPath) > 0)
1328adc4f0dbSShawn McCarney         {
1329adc4f0dbSShawn McCarney             return &inventoryItem;
1330adc4f0dbSShawn McCarney         }
1331adc4f0dbSShawn McCarney     }
1332adc4f0dbSShawn McCarney     return nullptr;
1333adc4f0dbSShawn McCarney }
1334adc4f0dbSShawn McCarney 
1335adc4f0dbSShawn McCarney /**
1336d500549bSAnthony Wilson  * @brief Finds the inventory item associated with the specified led path.
1337d500549bSAnthony Wilson  * @param inventoryItems D-Bus inventory items associated with sensors.
1338d500549bSAnthony Wilson  * @param ledObjPath D-Bus object path of led.
1339d500549bSAnthony Wilson  * @return Inventory item within vector, or nullptr if no match found.
1340d500549bSAnthony Wilson  */
1341d500549bSAnthony Wilson inline InventoryItem*
1342d500549bSAnthony Wilson     findInventoryItemForLed(std::vector<InventoryItem>& inventoryItems,
1343d500549bSAnthony Wilson                             const std::string& ledObjPath)
1344d500549bSAnthony Wilson {
1345d500549bSAnthony Wilson     for (InventoryItem& inventoryItem : inventoryItems)
1346d500549bSAnthony Wilson     {
1347d500549bSAnthony Wilson         if (inventoryItem.ledObjectPath == ledObjPath)
1348d500549bSAnthony Wilson         {
1349d500549bSAnthony Wilson             return &inventoryItem;
1350d500549bSAnthony Wilson         }
1351d500549bSAnthony Wilson     }
1352d500549bSAnthony Wilson     return nullptr;
1353d500549bSAnthony Wilson }
1354d500549bSAnthony Wilson 
1355d500549bSAnthony Wilson /**
1356adc4f0dbSShawn McCarney  * @brief Adds inventory item and associated sensor to specified vector.
1357adc4f0dbSShawn McCarney  *
1358adc4f0dbSShawn McCarney  * Adds a new InventoryItem to the vector if necessary.  Searches for an
1359adc4f0dbSShawn McCarney  * existing InventoryItem with the specified object path.  If not found, one is
1360adc4f0dbSShawn McCarney  * added to the vector.
1361adc4f0dbSShawn McCarney  *
1362adc4f0dbSShawn McCarney  * Next, the specified sensor is added to the set of sensors associated with the
1363adc4f0dbSShawn McCarney  * InventoryItem.
1364adc4f0dbSShawn McCarney  *
1365adc4f0dbSShawn McCarney  * @param inventoryItems D-Bus inventory items associated with sensors.
1366adc4f0dbSShawn McCarney  * @param invItemObjPath D-Bus object path of inventory item.
1367adc4f0dbSShawn McCarney  * @param sensorObjPath D-Bus object path of sensor
1368adc4f0dbSShawn McCarney  */
1369b5a76932SEd Tanous inline void addInventoryItem(
1370b5a76932SEd Tanous     const std::shared_ptr<std::vector<InventoryItem>>& inventoryItems,
1371b5a76932SEd Tanous     const std::string& invItemObjPath, const std::string& sensorObjPath)
1372adc4f0dbSShawn McCarney {
1373adc4f0dbSShawn McCarney     // Look for inventory item in vector
1374adc4f0dbSShawn McCarney     InventoryItem* inventoryItem =
1375adc4f0dbSShawn McCarney         findInventoryItem(inventoryItems, invItemObjPath);
1376adc4f0dbSShawn McCarney 
1377adc4f0dbSShawn McCarney     // If inventory item doesn't exist in vector, add it
1378adc4f0dbSShawn McCarney     if (inventoryItem == nullptr)
1379adc4f0dbSShawn McCarney     {
1380adc4f0dbSShawn McCarney         inventoryItems->emplace_back(invItemObjPath);
1381adc4f0dbSShawn McCarney         inventoryItem = &(inventoryItems->back());
1382adc4f0dbSShawn McCarney     }
1383adc4f0dbSShawn McCarney 
1384adc4f0dbSShawn McCarney     // Add sensor to set of sensors associated with inventory item
1385adc4f0dbSShawn McCarney     inventoryItem->sensors.emplace(sensorObjPath);
1386adc4f0dbSShawn McCarney }
1387adc4f0dbSShawn McCarney 
1388adc4f0dbSShawn McCarney /**
1389adc4f0dbSShawn McCarney  * @brief Stores D-Bus data in the specified inventory item.
1390adc4f0dbSShawn McCarney  *
1391adc4f0dbSShawn McCarney  * Finds D-Bus data in the specified map of interfaces.  Stores the data in the
1392adc4f0dbSShawn McCarney  * specified InventoryItem.
1393adc4f0dbSShawn McCarney  *
1394adc4f0dbSShawn McCarney  * This data is later used to provide sensor property values in the JSON
1395adc4f0dbSShawn McCarney  * response.
1396adc4f0dbSShawn McCarney  *
1397adc4f0dbSShawn McCarney  * @param inventoryItem Inventory item where data will be stored.
1398adc4f0dbSShawn McCarney  * @param interfacesDict Map containing D-Bus interfaces and their properties
1399adc4f0dbSShawn McCarney  * for the specified inventory item.
1400adc4f0dbSShawn McCarney  */
140123a21a1cSEd Tanous inline void storeInventoryItemData(
1402adc4f0dbSShawn McCarney     InventoryItem& inventoryItem,
1403711ac7a9SEd Tanous     const dbus::utility::DBusInteracesMap& interfacesDict)
14048fb49dd6SShawn McCarney {
1405adc4f0dbSShawn McCarney     // Get properties from Inventory.Item interface
1406711ac7a9SEd Tanous 
14079eb808c1SEd Tanous     for (const auto& [interface, values] : interfacesDict)
14088fb49dd6SShawn McCarney     {
1409711ac7a9SEd Tanous         if (interface == "xyz.openbmc_project.Inventory.Item")
14108fb49dd6SShawn McCarney         {
14119eb808c1SEd Tanous             for (const auto& [name, dbusValue] : values)
1412711ac7a9SEd Tanous             {
1413711ac7a9SEd Tanous                 if (name == "Present")
1414711ac7a9SEd Tanous                 {
1415711ac7a9SEd Tanous                     const bool* value = std::get_if<bool>(&dbusValue);
1416adc4f0dbSShawn McCarney                     if (value != nullptr)
14178fb49dd6SShawn McCarney                     {
1418adc4f0dbSShawn McCarney                         inventoryItem.isPresent = *value;
14198fb49dd6SShawn McCarney                     }
14208fb49dd6SShawn McCarney                 }
14218fb49dd6SShawn McCarney             }
1422711ac7a9SEd Tanous         }
1423adc4f0dbSShawn McCarney         // Check if Inventory.Item.PowerSupply interface is present
1424711ac7a9SEd Tanous 
1425711ac7a9SEd Tanous         if (interface == "xyz.openbmc_project.Inventory.Item.PowerSupply")
14268fb49dd6SShawn McCarney         {
1427adc4f0dbSShawn McCarney             inventoryItem.isPowerSupply = true;
14288fb49dd6SShawn McCarney         }
1429adc4f0dbSShawn McCarney 
1430adc4f0dbSShawn McCarney         // Get properties from Inventory.Decorator.Asset interface
1431711ac7a9SEd Tanous         if (interface == "xyz.openbmc_project.Inventory.Decorator.Asset")
1432adc4f0dbSShawn McCarney         {
14339eb808c1SEd Tanous             for (const auto& [name, dbusValue] : values)
1434711ac7a9SEd Tanous             {
1435711ac7a9SEd Tanous                 if (name == "Manufacturer")
1436adc4f0dbSShawn McCarney                 {
1437adc4f0dbSShawn McCarney                     const std::string* value =
1438711ac7a9SEd Tanous                         std::get_if<std::string>(&dbusValue);
1439adc4f0dbSShawn McCarney                     if (value != nullptr)
1440adc4f0dbSShawn McCarney                     {
1441adc4f0dbSShawn McCarney                         inventoryItem.manufacturer = *value;
1442adc4f0dbSShawn McCarney                     }
1443adc4f0dbSShawn McCarney                 }
1444711ac7a9SEd Tanous                 if (name == "Model")
1445adc4f0dbSShawn McCarney                 {
1446adc4f0dbSShawn McCarney                     const std::string* value =
1447711ac7a9SEd Tanous                         std::get_if<std::string>(&dbusValue);
1448adc4f0dbSShawn McCarney                     if (value != nullptr)
1449adc4f0dbSShawn McCarney                     {
1450adc4f0dbSShawn McCarney                         inventoryItem.model = *value;
1451adc4f0dbSShawn McCarney                     }
1452adc4f0dbSShawn McCarney                 }
1453711ac7a9SEd Tanous                 if (name == "SerialNumber")
1454adc4f0dbSShawn McCarney                 {
1455adc4f0dbSShawn McCarney                     const std::string* value =
1456711ac7a9SEd Tanous                         std::get_if<std::string>(&dbusValue);
1457adc4f0dbSShawn McCarney                     if (value != nullptr)
1458adc4f0dbSShawn McCarney                     {
1459adc4f0dbSShawn McCarney                         inventoryItem.serialNumber = *value;
1460adc4f0dbSShawn McCarney                     }
1461adc4f0dbSShawn McCarney                 }
1462711ac7a9SEd Tanous                 if (name == "PartNumber")
1463711ac7a9SEd Tanous                 {
1464711ac7a9SEd Tanous                     const std::string* value =
1465711ac7a9SEd Tanous                         std::get_if<std::string>(&dbusValue);
1466711ac7a9SEd Tanous                     if (value != nullptr)
1467711ac7a9SEd Tanous                     {
1468711ac7a9SEd Tanous                         inventoryItem.partNumber = *value;
1469711ac7a9SEd Tanous                     }
1470711ac7a9SEd Tanous                 }
1471711ac7a9SEd Tanous             }
1472adc4f0dbSShawn McCarney         }
1473adc4f0dbSShawn McCarney 
1474711ac7a9SEd Tanous         if (interface ==
1475711ac7a9SEd Tanous             "xyz.openbmc_project.State.Decorator.OperationalStatus")
1476adc4f0dbSShawn McCarney         {
14779eb808c1SEd Tanous             for (const auto& [name, dbusValue] : values)
1478adc4f0dbSShawn McCarney             {
1479711ac7a9SEd Tanous                 if (name == "Functional")
1480711ac7a9SEd Tanous                 {
1481711ac7a9SEd Tanous                     const bool* value = std::get_if<bool>(&dbusValue);
1482adc4f0dbSShawn McCarney                     if (value != nullptr)
1483adc4f0dbSShawn McCarney                     {
1484adc4f0dbSShawn McCarney                         inventoryItem.isFunctional = *value;
14858fb49dd6SShawn McCarney                     }
14868fb49dd6SShawn McCarney                 }
14878fb49dd6SShawn McCarney             }
14888fb49dd6SShawn McCarney         }
1489711ac7a9SEd Tanous     }
1490711ac7a9SEd Tanous }
14918fb49dd6SShawn McCarney 
14928fb49dd6SShawn McCarney /**
1493adc4f0dbSShawn McCarney  * @brief Gets D-Bus data for inventory items associated with sensors.
14948fb49dd6SShawn McCarney  *
1495adc4f0dbSShawn McCarney  * Uses the specified connections (services) to obtain D-Bus data for inventory
1496adc4f0dbSShawn McCarney  * items associated with sensors.  Stores the resulting data in the
1497adc4f0dbSShawn McCarney  * inventoryItems vector.
14988fb49dd6SShawn McCarney  *
1499adc4f0dbSShawn McCarney  * This data is later used to provide sensor property values in the JSON
1500adc4f0dbSShawn McCarney  * response.
1501adc4f0dbSShawn McCarney  *
1502adc4f0dbSShawn McCarney  * Finds the inventory item data asynchronously.  Invokes callback when data has
1503adc4f0dbSShawn McCarney  * been obtained.
1504adc4f0dbSShawn McCarney  *
1505adc4f0dbSShawn McCarney  * The callback must have the following signature:
1506adc4f0dbSShawn McCarney  *   @code
1507d500549bSAnthony Wilson  *   callback(void)
1508adc4f0dbSShawn McCarney  *   @endcode
1509adc4f0dbSShawn McCarney  *
1510adc4f0dbSShawn McCarney  * This function is called recursively, obtaining data asynchronously from one
1511adc4f0dbSShawn McCarney  * connection in each call.  This ensures the callback is not invoked until the
1512adc4f0dbSShawn McCarney  * last asynchronous function has completed.
15138fb49dd6SShawn McCarney  *
15148fb49dd6SShawn McCarney  * @param sensorsAsyncResp Pointer to object holding response data.
1515adc4f0dbSShawn McCarney  * @param inventoryItems D-Bus inventory items associated with sensors.
1516adc4f0dbSShawn McCarney  * @param invConnections Connections that provide data for the inventory items.
15178fb49dd6SShawn McCarney  * @param objectMgrPaths Mappings from connection name to DBus object path that
15188fb49dd6SShawn McCarney  * implements ObjectManager.
1519adc4f0dbSShawn McCarney  * @param callback Callback to invoke when inventory data has been obtained.
1520adc4f0dbSShawn McCarney  * @param invConnectionsIndex Current index in invConnections.  Only specified
1521adc4f0dbSShawn McCarney  * in recursive calls to this function.
15228fb49dd6SShawn McCarney  */
1523adc4f0dbSShawn McCarney template <typename Callback>
1524adc4f0dbSShawn McCarney static void getInventoryItemsData(
15258fb49dd6SShawn McCarney     std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp,
1526adc4f0dbSShawn McCarney     std::shared_ptr<std::vector<InventoryItem>> inventoryItems,
1527fe04d49cSNan Zhou     std::shared_ptr<std::set<std::string>> invConnections,
1528fe04d49cSNan Zhou     std::shared_ptr<std::map<std::string, std::string>> objectMgrPaths,
1529271584abSEd Tanous     Callback&& callback, size_t invConnectionsIndex = 0)
15308fb49dd6SShawn McCarney {
1531adc4f0dbSShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItemsData enter";
15328fb49dd6SShawn McCarney 
1533adc4f0dbSShawn McCarney     // If no more connections left, call callback
1534adc4f0dbSShawn McCarney     if (invConnectionsIndex >= invConnections->size())
15358fb49dd6SShawn McCarney     {
1536d500549bSAnthony Wilson         callback();
1537adc4f0dbSShawn McCarney         BMCWEB_LOG_DEBUG << "getInventoryItemsData exit";
1538adc4f0dbSShawn McCarney         return;
1539adc4f0dbSShawn McCarney     }
1540adc4f0dbSShawn McCarney 
1541adc4f0dbSShawn McCarney     // Get inventory item data from current connection
1542fe04d49cSNan Zhou     auto it = invConnections->begin();
1543fe04d49cSNan Zhou     std::advance(it, invConnectionsIndex);
1544adc4f0dbSShawn McCarney     if (it != invConnections->end())
1545adc4f0dbSShawn McCarney     {
1546adc4f0dbSShawn McCarney         const std::string& invConnection = *it;
1547adc4f0dbSShawn McCarney 
15488fb49dd6SShawn McCarney         // Response handler for GetManagedObjects
1549002d39b4SEd Tanous         auto respHandler =
1550002d39b4SEd Tanous             [sensorsAsyncResp, inventoryItems, invConnections, objectMgrPaths,
155102cad96eSEd Tanous              callback{std::forward<Callback>(callback)}, invConnectionsIndex](
155202cad96eSEd Tanous                 const boost::system::error_code ec,
155302cad96eSEd Tanous                 const dbus::utility::ManagedObjectType& resp) {
1554adc4f0dbSShawn McCarney             BMCWEB_LOG_DEBUG << "getInventoryItemsData respHandler enter";
15558fb49dd6SShawn McCarney             if (ec)
15568fb49dd6SShawn McCarney             {
15578fb49dd6SShawn McCarney                 BMCWEB_LOG_ERROR
1558adc4f0dbSShawn McCarney                     << "getInventoryItemsData respHandler DBus error " << ec;
15598d1b46d7Szhanghch05                 messages::internalError(sensorsAsyncResp->asyncResp->res);
15608fb49dd6SShawn McCarney                 return;
15618fb49dd6SShawn McCarney             }
15628fb49dd6SShawn McCarney 
15638fb49dd6SShawn McCarney             // Loop through returned object paths
15648fb49dd6SShawn McCarney             for (const auto& objDictEntry : resp)
15658fb49dd6SShawn McCarney             {
15668fb49dd6SShawn McCarney                 const std::string& objPath =
15678fb49dd6SShawn McCarney                     static_cast<const std::string&>(objDictEntry.first);
15688fb49dd6SShawn McCarney 
1569adc4f0dbSShawn McCarney                 // If this object path is one of the specified inventory items
1570adc4f0dbSShawn McCarney                 InventoryItem* inventoryItem =
1571adc4f0dbSShawn McCarney                     findInventoryItem(inventoryItems, objPath);
1572adc4f0dbSShawn McCarney                 if (inventoryItem != nullptr)
15738fb49dd6SShawn McCarney                 {
1574adc4f0dbSShawn McCarney                     // Store inventory data in InventoryItem
1575adc4f0dbSShawn McCarney                     storeInventoryItemData(*inventoryItem, objDictEntry.second);
15768fb49dd6SShawn McCarney                 }
15778fb49dd6SShawn McCarney             }
15788fb49dd6SShawn McCarney 
1579adc4f0dbSShawn McCarney             // Recurse to get inventory item data from next connection
1580adc4f0dbSShawn McCarney             getInventoryItemsData(sensorsAsyncResp, inventoryItems,
1581adc4f0dbSShawn McCarney                                   invConnections, objectMgrPaths,
1582adc4f0dbSShawn McCarney                                   std::move(callback), invConnectionsIndex + 1);
1583adc4f0dbSShawn McCarney 
1584adc4f0dbSShawn McCarney             BMCWEB_LOG_DEBUG << "getInventoryItemsData respHandler exit";
15858fb49dd6SShawn McCarney         };
15868fb49dd6SShawn McCarney 
15878fb49dd6SShawn McCarney         // Find DBus object path that implements ObjectManager for the current
15888fb49dd6SShawn McCarney         // connection.  If no mapping found, default to "/".
15898fb49dd6SShawn McCarney         auto iter = objectMgrPaths->find(invConnection);
15908fb49dd6SShawn McCarney         const std::string& objectMgrPath =
15918fb49dd6SShawn McCarney             (iter != objectMgrPaths->end()) ? iter->second : "/";
15928fb49dd6SShawn McCarney         BMCWEB_LOG_DEBUG << "ObjectManager path for " << invConnection << " is "
15938fb49dd6SShawn McCarney                          << objectMgrPath;
15948fb49dd6SShawn McCarney 
15958fb49dd6SShawn McCarney         // Get all object paths and their interfaces for current connection
15968fb49dd6SShawn McCarney         crow::connections::systemBus->async_method_call(
15978fb49dd6SShawn McCarney             std::move(respHandler), invConnection, objectMgrPath,
15988fb49dd6SShawn McCarney             "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
15998fb49dd6SShawn McCarney     }
16008fb49dd6SShawn McCarney 
1601adc4f0dbSShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItemsData exit";
16028fb49dd6SShawn McCarney }
16038fb49dd6SShawn McCarney 
16048fb49dd6SShawn McCarney /**
1605adc4f0dbSShawn McCarney  * @brief Gets connections that provide D-Bus data for inventory items.
16068fb49dd6SShawn McCarney  *
1607adc4f0dbSShawn McCarney  * Gets the D-Bus connections (services) that provide data for the inventory
1608adc4f0dbSShawn McCarney  * items that are associated with sensors.
16098fb49dd6SShawn McCarney  *
16108fb49dd6SShawn McCarney  * Finds the connections asynchronously.  Invokes callback when information has
16118fb49dd6SShawn McCarney  * been obtained.
16128fb49dd6SShawn McCarney  *
16138fb49dd6SShawn McCarney  * The callback must have the following signature:
16148fb49dd6SShawn McCarney  *   @code
1615fe04d49cSNan Zhou  *   callback(std::shared_ptr<std::set<std::string>> invConnections)
16168fb49dd6SShawn McCarney  *   @endcode
16178fb49dd6SShawn McCarney  *
16188fb49dd6SShawn McCarney  * @param sensorsAsyncResp Pointer to object holding response data.
1619adc4f0dbSShawn McCarney  * @param inventoryItems D-Bus inventory items associated with sensors.
16208fb49dd6SShawn McCarney  * @param callback Callback to invoke when connections have been obtained.
16218fb49dd6SShawn McCarney  */
16228fb49dd6SShawn McCarney template <typename Callback>
16238fb49dd6SShawn McCarney static void getInventoryItemsConnections(
1624b5a76932SEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
1625b5a76932SEd Tanous     const std::shared_ptr<std::vector<InventoryItem>>& inventoryItems,
16268fb49dd6SShawn McCarney     Callback&& callback)
16278fb49dd6SShawn McCarney {
16288fb49dd6SShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItemsConnections enter";
16298fb49dd6SShawn McCarney 
16308fb49dd6SShawn McCarney     const std::string path = "/xyz/openbmc_project/inventory";
1631adc4f0dbSShawn McCarney     const std::array<std::string, 4> interfaces = {
16328fb49dd6SShawn McCarney         "xyz.openbmc_project.Inventory.Item",
1633adc4f0dbSShawn McCarney         "xyz.openbmc_project.Inventory.Item.PowerSupply",
1634adc4f0dbSShawn McCarney         "xyz.openbmc_project.Inventory.Decorator.Asset",
16358fb49dd6SShawn McCarney         "xyz.openbmc_project.State.Decorator.OperationalStatus"};
16368fb49dd6SShawn McCarney 
16378fb49dd6SShawn McCarney     // Response handler for parsing output from GetSubTree
1638002d39b4SEd Tanous     auto respHandler =
1639002d39b4SEd Tanous         [callback{std::forward<Callback>(callback)}, sensorsAsyncResp,
1640002d39b4SEd Tanous          inventoryItems](
1641b9d36b47SEd Tanous             const boost::system::error_code ec,
1642002d39b4SEd Tanous             const dbus::utility::MapperGetSubTreeResponse& subtree) {
16438fb49dd6SShawn McCarney         BMCWEB_LOG_DEBUG << "getInventoryItemsConnections respHandler enter";
16448fb49dd6SShawn McCarney         if (ec)
16458fb49dd6SShawn McCarney         {
16468d1b46d7Szhanghch05             messages::internalError(sensorsAsyncResp->asyncResp->res);
16478fb49dd6SShawn McCarney             BMCWEB_LOG_ERROR
16488fb49dd6SShawn McCarney                 << "getInventoryItemsConnections respHandler DBus error " << ec;
16498fb49dd6SShawn McCarney             return;
16508fb49dd6SShawn McCarney         }
16518fb49dd6SShawn McCarney 
16528fb49dd6SShawn McCarney         // Make unique list of connections for desired inventory items
1653fe04d49cSNan Zhou         std::shared_ptr<std::set<std::string>> invConnections =
1654fe04d49cSNan Zhou             std::make_shared<std::set<std::string>>();
16558fb49dd6SShawn McCarney 
16568fb49dd6SShawn McCarney         // Loop through objects from GetSubTree
16578fb49dd6SShawn McCarney         for (const std::pair<
16588fb49dd6SShawn McCarney                  std::string,
16598fb49dd6SShawn McCarney                  std::vector<std::pair<std::string, std::vector<std::string>>>>&
16608fb49dd6SShawn McCarney                  object : subtree)
16618fb49dd6SShawn McCarney         {
1662adc4f0dbSShawn McCarney             // Check if object path is one of the specified inventory items
16638fb49dd6SShawn McCarney             const std::string& objPath = object.first;
1664adc4f0dbSShawn McCarney             if (findInventoryItem(inventoryItems, objPath) != nullptr)
16658fb49dd6SShawn McCarney             {
16668fb49dd6SShawn McCarney                 // Store all connections to inventory item
16678fb49dd6SShawn McCarney                 for (const std::pair<std::string, std::vector<std::string>>&
16688fb49dd6SShawn McCarney                          objData : object.second)
16698fb49dd6SShawn McCarney                 {
16708fb49dd6SShawn McCarney                     const std::string& invConnection = objData.first;
16718fb49dd6SShawn McCarney                     invConnections->insert(invConnection);
16728fb49dd6SShawn McCarney                 }
16738fb49dd6SShawn McCarney             }
16748fb49dd6SShawn McCarney         }
1675d500549bSAnthony Wilson 
16768fb49dd6SShawn McCarney         callback(invConnections);
16778fb49dd6SShawn McCarney         BMCWEB_LOG_DEBUG << "getInventoryItemsConnections respHandler exit";
16788fb49dd6SShawn McCarney     };
16798fb49dd6SShawn McCarney 
16808fb49dd6SShawn McCarney     // Make call to ObjectMapper to find all inventory items
16818fb49dd6SShawn McCarney     crow::connections::systemBus->async_method_call(
16828fb49dd6SShawn McCarney         std::move(respHandler), "xyz.openbmc_project.ObjectMapper",
16838fb49dd6SShawn McCarney         "/xyz/openbmc_project/object_mapper",
16848fb49dd6SShawn McCarney         "xyz.openbmc_project.ObjectMapper", "GetSubTree", path, 0, interfaces);
16858fb49dd6SShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItemsConnections exit";
16868fb49dd6SShawn McCarney }
16878fb49dd6SShawn McCarney 
16888fb49dd6SShawn McCarney /**
1689adc4f0dbSShawn McCarney  * @brief Gets associations from sensors to inventory items.
16908fb49dd6SShawn McCarney  *
16918fb49dd6SShawn McCarney  * Looks for ObjectMapper associations from the specified sensors to related
1692d500549bSAnthony Wilson  * inventory items. Then finds the associations from those inventory items to
1693d500549bSAnthony Wilson  * their LEDs, if any.
16948fb49dd6SShawn McCarney  *
16958fb49dd6SShawn McCarney  * Finds the inventory items asynchronously.  Invokes callback when information
16968fb49dd6SShawn McCarney  * has been obtained.
16978fb49dd6SShawn McCarney  *
16988fb49dd6SShawn McCarney  * The callback must have the following signature:
16998fb49dd6SShawn McCarney  *   @code
1700adc4f0dbSShawn McCarney  *   callback(std::shared_ptr<std::vector<InventoryItem>> inventoryItems)
17018fb49dd6SShawn McCarney  *   @endcode
17028fb49dd6SShawn McCarney  *
17038fb49dd6SShawn McCarney  * @param sensorsAsyncResp Pointer to object holding response data.
17048fb49dd6SShawn McCarney  * @param sensorNames All sensors within the current chassis.
17058fb49dd6SShawn McCarney  * @param objectMgrPaths Mappings from connection name to DBus object path that
17068fb49dd6SShawn McCarney  * implements ObjectManager.
17078fb49dd6SShawn McCarney  * @param callback Callback to invoke when inventory items have been obtained.
17088fb49dd6SShawn McCarney  */
17098fb49dd6SShawn McCarney template <typename Callback>
1710adc4f0dbSShawn McCarney static void getInventoryItemAssociations(
1711b5a76932SEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
1712fe04d49cSNan Zhou     const std::shared_ptr<std::set<std::string>>& sensorNames,
1713fe04d49cSNan Zhou     const std::shared_ptr<std::map<std::string, std::string>>& objectMgrPaths,
17148fb49dd6SShawn McCarney     Callback&& callback)
17158fb49dd6SShawn McCarney {
1716adc4f0dbSShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItemAssociations enter";
17178fb49dd6SShawn McCarney 
17188fb49dd6SShawn McCarney     // Response handler for GetManagedObjects
171902cad96eSEd Tanous     auto respHandler =
172002cad96eSEd Tanous         [callback{std::forward<Callback>(callback)}, sensorsAsyncResp,
17218fb49dd6SShawn McCarney          sensorNames](const boost::system::error_code ec,
172202cad96eSEd Tanous                       const dbus::utility::ManagedObjectType& resp) {
1723adc4f0dbSShawn McCarney         BMCWEB_LOG_DEBUG << "getInventoryItemAssociations respHandler enter";
17248fb49dd6SShawn McCarney         if (ec)
17258fb49dd6SShawn McCarney         {
1726adc4f0dbSShawn McCarney             BMCWEB_LOG_ERROR
1727adc4f0dbSShawn McCarney                 << "getInventoryItemAssociations respHandler DBus error " << ec;
17288d1b46d7Szhanghch05             messages::internalError(sensorsAsyncResp->asyncResp->res);
17298fb49dd6SShawn McCarney             return;
17308fb49dd6SShawn McCarney         }
17318fb49dd6SShawn McCarney 
1732adc4f0dbSShawn McCarney         // Create vector to hold list of inventory items
1733adc4f0dbSShawn McCarney         std::shared_ptr<std::vector<InventoryItem>> inventoryItems =
1734adc4f0dbSShawn McCarney             std::make_shared<std::vector<InventoryItem>>();
1735adc4f0dbSShawn McCarney 
17368fb49dd6SShawn McCarney         // Loop through returned object paths
17378fb49dd6SShawn McCarney         std::string sensorAssocPath;
17388fb49dd6SShawn McCarney         sensorAssocPath.reserve(128); // avoid memory allocations
17398fb49dd6SShawn McCarney         for (const auto& objDictEntry : resp)
17408fb49dd6SShawn McCarney         {
17418fb49dd6SShawn McCarney             const std::string& objPath =
17428fb49dd6SShawn McCarney                 static_cast<const std::string&>(objDictEntry.first);
17438fb49dd6SShawn McCarney 
17448fb49dd6SShawn McCarney             // If path is inventory association for one of the specified sensors
17458fb49dd6SShawn McCarney             for (const std::string& sensorName : *sensorNames)
17468fb49dd6SShawn McCarney             {
17478fb49dd6SShawn McCarney                 sensorAssocPath = sensorName;
17488fb49dd6SShawn McCarney                 sensorAssocPath += "/inventory";
17498fb49dd6SShawn McCarney                 if (objPath == sensorAssocPath)
17508fb49dd6SShawn McCarney                 {
17518fb49dd6SShawn McCarney                     // Get Association interface for object path
1752711ac7a9SEd Tanous                     for (const auto& [interface, values] : objDictEntry.second)
17538fb49dd6SShawn McCarney                     {
1754711ac7a9SEd Tanous                         if (interface == "xyz.openbmc_project.Association")
1755711ac7a9SEd Tanous                         {
1756711ac7a9SEd Tanous                             for (const auto& [valueName, value] : values)
1757711ac7a9SEd Tanous                             {
1758711ac7a9SEd Tanous                                 if (valueName == "endpoints")
17598fb49dd6SShawn McCarney                                 {
17608fb49dd6SShawn McCarney                                     const std::vector<std::string>* endpoints =
17618fb49dd6SShawn McCarney                                         std::get_if<std::vector<std::string>>(
1762711ac7a9SEd Tanous                                             &value);
1763711ac7a9SEd Tanous                                     if ((endpoints != nullptr) &&
1764711ac7a9SEd Tanous                                         !endpoints->empty())
17658fb49dd6SShawn McCarney                                     {
1766adc4f0dbSShawn McCarney                                         // Add inventory item to vector
1767adc4f0dbSShawn McCarney                                         const std::string& invItemPath =
1768adc4f0dbSShawn McCarney                                             endpoints->front();
1769711ac7a9SEd Tanous                                         addInventoryItem(inventoryItems,
1770711ac7a9SEd Tanous                                                          invItemPath,
1771adc4f0dbSShawn McCarney                                                          sensorName);
17728fb49dd6SShawn McCarney                                     }
17738fb49dd6SShawn McCarney                                 }
17748fb49dd6SShawn McCarney                             }
1775711ac7a9SEd Tanous                         }
1776711ac7a9SEd Tanous                     }
17778fb49dd6SShawn McCarney                     break;
17788fb49dd6SShawn McCarney                 }
17798fb49dd6SShawn McCarney             }
17808fb49dd6SShawn McCarney         }
17818fb49dd6SShawn McCarney 
1782d500549bSAnthony Wilson         // Now loop through the returned object paths again, this time to
1783d500549bSAnthony Wilson         // find the leds associated with the inventory items we just found
1784d500549bSAnthony Wilson         std::string inventoryAssocPath;
1785d500549bSAnthony Wilson         inventoryAssocPath.reserve(128); // avoid memory allocations
1786d500549bSAnthony Wilson         for (const auto& objDictEntry : resp)
1787d500549bSAnthony Wilson         {
1788d500549bSAnthony Wilson             const std::string& objPath =
1789d500549bSAnthony Wilson                 static_cast<const std::string&>(objDictEntry.first);
1790d500549bSAnthony Wilson 
1791d500549bSAnthony Wilson             for (InventoryItem& inventoryItem : *inventoryItems)
1792d500549bSAnthony Wilson             {
1793d500549bSAnthony Wilson                 inventoryAssocPath = inventoryItem.objectPath;
1794d500549bSAnthony Wilson                 inventoryAssocPath += "/leds";
1795d500549bSAnthony Wilson                 if (objPath == inventoryAssocPath)
1796d500549bSAnthony Wilson                 {
1797711ac7a9SEd Tanous                     for (const auto& [interface, values] : objDictEntry.second)
1798d500549bSAnthony Wilson                     {
1799711ac7a9SEd Tanous                         if (interface == "xyz.openbmc_project.Association")
1800711ac7a9SEd Tanous                         {
1801711ac7a9SEd Tanous                             for (const auto& [valueName, value] : values)
1802711ac7a9SEd Tanous                             {
1803711ac7a9SEd Tanous                                 if (valueName == "endpoints")
1804d500549bSAnthony Wilson                                 {
1805d500549bSAnthony Wilson                                     const std::vector<std::string>* endpoints =
1806d500549bSAnthony Wilson                                         std::get_if<std::vector<std::string>>(
1807711ac7a9SEd Tanous                                             &value);
1808711ac7a9SEd Tanous                                     if ((endpoints != nullptr) &&
1809711ac7a9SEd Tanous                                         !endpoints->empty())
1810d500549bSAnthony Wilson                                     {
1811711ac7a9SEd Tanous                                         // Add inventory item to vector
1812d500549bSAnthony Wilson                                         // Store LED path in inventory item
1813711ac7a9SEd Tanous                                         const std::string& ledPath =
1814711ac7a9SEd Tanous                                             endpoints->front();
1815d500549bSAnthony Wilson                                         inventoryItem.ledObjectPath = ledPath;
1816d500549bSAnthony Wilson                                     }
1817d500549bSAnthony Wilson                                 }
1818d500549bSAnthony Wilson                             }
1819711ac7a9SEd Tanous                         }
1820711ac7a9SEd Tanous                     }
1821711ac7a9SEd Tanous 
1822d500549bSAnthony Wilson                     break;
1823d500549bSAnthony Wilson                 }
1824d500549bSAnthony Wilson             }
1825d500549bSAnthony Wilson         }
1826adc4f0dbSShawn McCarney         callback(inventoryItems);
1827adc4f0dbSShawn McCarney         BMCWEB_LOG_DEBUG << "getInventoryItemAssociations respHandler exit";
18288fb49dd6SShawn McCarney     };
18298fb49dd6SShawn McCarney 
18308fb49dd6SShawn McCarney     // Find DBus object path that implements ObjectManager for ObjectMapper
18318fb49dd6SShawn McCarney     std::string connection = "xyz.openbmc_project.ObjectMapper";
18328fb49dd6SShawn McCarney     auto iter = objectMgrPaths->find(connection);
18338fb49dd6SShawn McCarney     const std::string& objectMgrPath =
18348fb49dd6SShawn McCarney         (iter != objectMgrPaths->end()) ? iter->second : "/";
18358fb49dd6SShawn McCarney     BMCWEB_LOG_DEBUG << "ObjectManager path for " << connection << " is "
18368fb49dd6SShawn McCarney                      << objectMgrPath;
18378fb49dd6SShawn McCarney 
18388fb49dd6SShawn McCarney     // Call GetManagedObjects on the ObjectMapper to get all associations
18398fb49dd6SShawn McCarney     crow::connections::systemBus->async_method_call(
18408fb49dd6SShawn McCarney         std::move(respHandler), connection, objectMgrPath,
18418fb49dd6SShawn McCarney         "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
18428fb49dd6SShawn McCarney 
1843adc4f0dbSShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItemAssociations exit";
18448fb49dd6SShawn McCarney }
18458fb49dd6SShawn McCarney 
18468fb49dd6SShawn McCarney /**
1847d500549bSAnthony Wilson  * @brief Gets D-Bus data for inventory item leds associated with sensors.
1848d500549bSAnthony Wilson  *
1849d500549bSAnthony Wilson  * Uses the specified connections (services) to obtain D-Bus data for inventory
1850d500549bSAnthony Wilson  * item leds associated with sensors.  Stores the resulting data in the
1851d500549bSAnthony Wilson  * inventoryItems vector.
1852d500549bSAnthony Wilson  *
1853d500549bSAnthony Wilson  * This data is later used to provide sensor property values in the JSON
1854d500549bSAnthony Wilson  * response.
1855d500549bSAnthony Wilson  *
1856d500549bSAnthony Wilson  * Finds the inventory item led data asynchronously.  Invokes callback when data
1857d500549bSAnthony Wilson  * has been obtained.
1858d500549bSAnthony Wilson  *
1859d500549bSAnthony Wilson  * The callback must have the following signature:
1860d500549bSAnthony Wilson  *   @code
186142cbe538SGunnar Mills  *   callback()
1862d500549bSAnthony Wilson  *   @endcode
1863d500549bSAnthony Wilson  *
1864d500549bSAnthony Wilson  * This function is called recursively, obtaining data asynchronously from one
1865d500549bSAnthony Wilson  * connection in each call.  This ensures the callback is not invoked until the
1866d500549bSAnthony Wilson  * last asynchronous function has completed.
1867d500549bSAnthony Wilson  *
1868d500549bSAnthony Wilson  * @param sensorsAsyncResp Pointer to object holding response data.
1869d500549bSAnthony Wilson  * @param inventoryItems D-Bus inventory items associated with sensors.
1870d500549bSAnthony Wilson  * @param ledConnections Connections that provide data for the inventory leds.
1871d500549bSAnthony Wilson  * @param callback Callback to invoke when inventory data has been obtained.
1872d500549bSAnthony Wilson  * @param ledConnectionsIndex Current index in ledConnections.  Only specified
1873d500549bSAnthony Wilson  * in recursive calls to this function.
1874d500549bSAnthony Wilson  */
1875d500549bSAnthony Wilson template <typename Callback>
1876d500549bSAnthony Wilson void getInventoryLedData(
1877d500549bSAnthony Wilson     std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp,
1878d500549bSAnthony Wilson     std::shared_ptr<std::vector<InventoryItem>> inventoryItems,
1879fe04d49cSNan Zhou     std::shared_ptr<std::map<std::string, std::string>> ledConnections,
1880d500549bSAnthony Wilson     Callback&& callback, size_t ledConnectionsIndex = 0)
1881d500549bSAnthony Wilson {
1882d500549bSAnthony Wilson     BMCWEB_LOG_DEBUG << "getInventoryLedData enter";
1883d500549bSAnthony Wilson 
1884d500549bSAnthony Wilson     // If no more connections left, call callback
1885d500549bSAnthony Wilson     if (ledConnectionsIndex >= ledConnections->size())
1886d500549bSAnthony Wilson     {
188742cbe538SGunnar Mills         callback();
1888d500549bSAnthony Wilson         BMCWEB_LOG_DEBUG << "getInventoryLedData exit";
1889d500549bSAnthony Wilson         return;
1890d500549bSAnthony Wilson     }
1891d500549bSAnthony Wilson 
1892d500549bSAnthony Wilson     // Get inventory item data from current connection
1893fe04d49cSNan Zhou     auto it = ledConnections->begin();
1894fe04d49cSNan Zhou     std::advance(it, ledConnectionsIndex);
1895d500549bSAnthony Wilson     if (it != ledConnections->end())
1896d500549bSAnthony Wilson     {
1897d500549bSAnthony Wilson         const std::string& ledPath = (*it).first;
1898d500549bSAnthony Wilson         const std::string& ledConnection = (*it).second;
1899d500549bSAnthony Wilson         // Response handler for Get State property
19001e1e598dSJonathan Doman         auto respHandler =
19011e1e598dSJonathan Doman             [sensorsAsyncResp, inventoryItems, ledConnections, ledPath,
1902f94c4ecfSEd Tanous              callback{std::forward<Callback>(callback)}, ledConnectionsIndex](
19031e1e598dSJonathan Doman                 const boost::system::error_code ec, const std::string& state) {
1904d500549bSAnthony Wilson             BMCWEB_LOG_DEBUG << "getInventoryLedData respHandler enter";
1905d500549bSAnthony Wilson             if (ec)
1906d500549bSAnthony Wilson             {
1907d500549bSAnthony Wilson                 BMCWEB_LOG_ERROR
1908d500549bSAnthony Wilson                     << "getInventoryLedData respHandler DBus error " << ec;
19098d1b46d7Szhanghch05                 messages::internalError(sensorsAsyncResp->asyncResp->res);
1910d500549bSAnthony Wilson                 return;
1911d500549bSAnthony Wilson             }
1912d500549bSAnthony Wilson 
19131e1e598dSJonathan Doman             BMCWEB_LOG_DEBUG << "Led state: " << state;
1914d500549bSAnthony Wilson             // Find inventory item with this LED object path
1915d500549bSAnthony Wilson             InventoryItem* inventoryItem =
1916d500549bSAnthony Wilson                 findInventoryItemForLed(*inventoryItems, ledPath);
1917d500549bSAnthony Wilson             if (inventoryItem != nullptr)
1918d500549bSAnthony Wilson             {
1919d500549bSAnthony Wilson                 // Store LED state in InventoryItem
192011ba3979SEd Tanous                 if (state.ends_with("On"))
1921d500549bSAnthony Wilson                 {
1922d500549bSAnthony Wilson                     inventoryItem->ledState = LedState::ON;
1923d500549bSAnthony Wilson                 }
192411ba3979SEd Tanous                 else if (state.ends_with("Blink"))
1925d500549bSAnthony Wilson                 {
1926d500549bSAnthony Wilson                     inventoryItem->ledState = LedState::BLINK;
1927d500549bSAnthony Wilson                 }
192811ba3979SEd Tanous                 else if (state.ends_with("Off"))
1929d500549bSAnthony Wilson                 {
1930d500549bSAnthony Wilson                     inventoryItem->ledState = LedState::OFF;
1931d500549bSAnthony Wilson                 }
1932d500549bSAnthony Wilson                 else
1933d500549bSAnthony Wilson                 {
1934d500549bSAnthony Wilson                     inventoryItem->ledState = LedState::UNKNOWN;
1935d500549bSAnthony Wilson                 }
1936d500549bSAnthony Wilson             }
1937d500549bSAnthony Wilson 
1938d500549bSAnthony Wilson             // Recurse to get LED data from next connection
1939d500549bSAnthony Wilson             getInventoryLedData(sensorsAsyncResp, inventoryItems,
1940d500549bSAnthony Wilson                                 ledConnections, std::move(callback),
1941d500549bSAnthony Wilson                                 ledConnectionsIndex + 1);
1942d500549bSAnthony Wilson 
1943d500549bSAnthony Wilson             BMCWEB_LOG_DEBUG << "getInventoryLedData respHandler exit";
1944d500549bSAnthony Wilson         };
1945d500549bSAnthony Wilson 
1946d500549bSAnthony Wilson         // Get the State property for the current LED
19471e1e598dSJonathan Doman         sdbusplus::asio::getProperty<std::string>(
19481e1e598dSJonathan Doman             *crow::connections::systemBus, ledConnection, ledPath,
19491e1e598dSJonathan Doman             "xyz.openbmc_project.Led.Physical", "State",
19501e1e598dSJonathan Doman             std::move(respHandler));
1951d500549bSAnthony Wilson     }
1952d500549bSAnthony Wilson 
1953d500549bSAnthony Wilson     BMCWEB_LOG_DEBUG << "getInventoryLedData exit";
1954d500549bSAnthony Wilson }
1955d500549bSAnthony Wilson 
1956d500549bSAnthony Wilson /**
1957d500549bSAnthony Wilson  * @brief Gets LED data for LEDs associated with given inventory items.
1958d500549bSAnthony Wilson  *
1959d500549bSAnthony Wilson  * Gets the D-Bus connections (services) that provide LED data for the LEDs
1960d500549bSAnthony Wilson  * associated with the specified inventory items.  Then gets the LED data from
1961d500549bSAnthony Wilson  * each connection and stores it in the inventory item.
1962d500549bSAnthony Wilson  *
1963d500549bSAnthony Wilson  * This data is later used to provide sensor property values in the JSON
1964d500549bSAnthony Wilson  * response.
1965d500549bSAnthony Wilson  *
1966d500549bSAnthony Wilson  * Finds the LED data asynchronously.  Invokes callback when information has
1967d500549bSAnthony Wilson  * been obtained.
1968d500549bSAnthony Wilson  *
1969d500549bSAnthony Wilson  * The callback must have the following signature:
1970d500549bSAnthony Wilson  *   @code
197142cbe538SGunnar Mills  *   callback()
1972d500549bSAnthony Wilson  *   @endcode
1973d500549bSAnthony Wilson  *
1974d500549bSAnthony Wilson  * @param sensorsAsyncResp Pointer to object holding response data.
1975d500549bSAnthony Wilson  * @param inventoryItems D-Bus inventory items associated with sensors.
1976d500549bSAnthony Wilson  * @param callback Callback to invoke when inventory items have been obtained.
1977d500549bSAnthony Wilson  */
1978d500549bSAnthony Wilson template <typename Callback>
1979d500549bSAnthony Wilson void getInventoryLeds(
1980d500549bSAnthony Wilson     std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp,
1981d500549bSAnthony Wilson     std::shared_ptr<std::vector<InventoryItem>> inventoryItems,
1982d500549bSAnthony Wilson     Callback&& callback)
1983d500549bSAnthony Wilson {
1984d500549bSAnthony Wilson     BMCWEB_LOG_DEBUG << "getInventoryLeds enter";
1985d500549bSAnthony Wilson 
1986d500549bSAnthony Wilson     const std::string path = "/xyz/openbmc_project";
1987d500549bSAnthony Wilson     const std::array<std::string, 1> interfaces = {
1988d500549bSAnthony Wilson         "xyz.openbmc_project.Led.Physical"};
1989d500549bSAnthony Wilson 
1990d500549bSAnthony Wilson     // Response handler for parsing output from GetSubTree
1991002d39b4SEd Tanous     auto respHandler =
1992002d39b4SEd Tanous         [callback{std::forward<Callback>(callback)}, sensorsAsyncResp,
1993002d39b4SEd Tanous          inventoryItems](
1994b9d36b47SEd Tanous             const boost::system::error_code ec,
1995002d39b4SEd Tanous             const dbus::utility::MapperGetSubTreeResponse& subtree) {
1996d500549bSAnthony Wilson         BMCWEB_LOG_DEBUG << "getInventoryLeds respHandler enter";
1997d500549bSAnthony Wilson         if (ec)
1998d500549bSAnthony Wilson         {
19998d1b46d7Szhanghch05             messages::internalError(sensorsAsyncResp->asyncResp->res);
2000d500549bSAnthony Wilson             BMCWEB_LOG_ERROR << "getInventoryLeds respHandler DBus error "
2001d500549bSAnthony Wilson                              << ec;
2002d500549bSAnthony Wilson             return;
2003d500549bSAnthony Wilson         }
2004d500549bSAnthony Wilson 
2005d500549bSAnthony Wilson         // Build map of LED object paths to connections
2006fe04d49cSNan Zhou         std::shared_ptr<std::map<std::string, std::string>> ledConnections =
2007fe04d49cSNan Zhou             std::make_shared<std::map<std::string, std::string>>();
2008d500549bSAnthony Wilson 
2009d500549bSAnthony Wilson         // Loop through objects from GetSubTree
2010d500549bSAnthony Wilson         for (const std::pair<
2011d500549bSAnthony Wilson                  std::string,
2012d500549bSAnthony Wilson                  std::vector<std::pair<std::string, std::vector<std::string>>>>&
2013d500549bSAnthony Wilson                  object : subtree)
2014d500549bSAnthony Wilson         {
2015d500549bSAnthony Wilson             // Check if object path is LED for one of the specified inventory
2016d500549bSAnthony Wilson             // items
2017d500549bSAnthony Wilson             const std::string& ledPath = object.first;
2018d500549bSAnthony Wilson             if (findInventoryItemForLed(*inventoryItems, ledPath) != nullptr)
2019d500549bSAnthony Wilson             {
2020d500549bSAnthony Wilson                 // Add mapping from ledPath to connection
2021d500549bSAnthony Wilson                 const std::string& connection = object.second.begin()->first;
2022d500549bSAnthony Wilson                 (*ledConnections)[ledPath] = connection;
2023d500549bSAnthony Wilson                 BMCWEB_LOG_DEBUG << "Added mapping " << ledPath << " -> "
2024d500549bSAnthony Wilson                                  << connection;
2025d500549bSAnthony Wilson             }
2026d500549bSAnthony Wilson         }
2027d500549bSAnthony Wilson 
2028d500549bSAnthony Wilson         getInventoryLedData(sensorsAsyncResp, inventoryItems, ledConnections,
2029d500549bSAnthony Wilson                             std::move(callback));
2030d500549bSAnthony Wilson         BMCWEB_LOG_DEBUG << "getInventoryLeds respHandler exit";
2031d500549bSAnthony Wilson     };
2032d500549bSAnthony Wilson     // Make call to ObjectMapper to find all inventory items
2033d500549bSAnthony Wilson     crow::connections::systemBus->async_method_call(
2034d500549bSAnthony Wilson         std::move(respHandler), "xyz.openbmc_project.ObjectMapper",
2035d500549bSAnthony Wilson         "/xyz/openbmc_project/object_mapper",
2036d500549bSAnthony Wilson         "xyz.openbmc_project.ObjectMapper", "GetSubTree", path, 0, interfaces);
2037d500549bSAnthony Wilson     BMCWEB_LOG_DEBUG << "getInventoryLeds exit";
2038d500549bSAnthony Wilson }
2039d500549bSAnthony Wilson 
2040d500549bSAnthony Wilson /**
204142cbe538SGunnar Mills  * @brief Gets D-Bus data for Power Supply Attributes such as EfficiencyPercent
204242cbe538SGunnar Mills  *
204342cbe538SGunnar Mills  * Uses the specified connections (services) (currently assumes just one) to
204442cbe538SGunnar Mills  * obtain D-Bus data for Power Supply Attributes. Stores the resulting data in
204542cbe538SGunnar Mills  * the inventoryItems vector. Only stores data in Power Supply inventoryItems.
204642cbe538SGunnar Mills  *
204742cbe538SGunnar Mills  * This data is later used to provide sensor property values in the JSON
204842cbe538SGunnar Mills  * response.
204942cbe538SGunnar Mills  *
205042cbe538SGunnar Mills  * Finds the Power Supply Attributes data asynchronously.  Invokes callback
205142cbe538SGunnar Mills  * when data has been obtained.
205242cbe538SGunnar Mills  *
205342cbe538SGunnar Mills  * The callback must have the following signature:
205442cbe538SGunnar Mills  *   @code
205542cbe538SGunnar Mills  *   callback(std::shared_ptr<std::vector<InventoryItem>> inventoryItems)
205642cbe538SGunnar Mills  *   @endcode
205742cbe538SGunnar Mills  *
205842cbe538SGunnar Mills  * @param sensorsAsyncResp Pointer to object holding response data.
205942cbe538SGunnar Mills  * @param inventoryItems D-Bus inventory items associated with sensors.
206042cbe538SGunnar Mills  * @param psAttributesConnections Connections that provide data for the Power
206142cbe538SGunnar Mills  *        Supply Attributes
206242cbe538SGunnar Mills  * @param callback Callback to invoke when data has been obtained.
206342cbe538SGunnar Mills  */
206442cbe538SGunnar Mills template <typename Callback>
206542cbe538SGunnar Mills void getPowerSupplyAttributesData(
2066b5a76932SEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
206742cbe538SGunnar Mills     std::shared_ptr<std::vector<InventoryItem>> inventoryItems,
2068fe04d49cSNan Zhou     const std::map<std::string, std::string>& psAttributesConnections,
206942cbe538SGunnar Mills     Callback&& callback)
207042cbe538SGunnar Mills {
207142cbe538SGunnar Mills     BMCWEB_LOG_DEBUG << "getPowerSupplyAttributesData enter";
207242cbe538SGunnar Mills 
207342cbe538SGunnar Mills     if (psAttributesConnections.empty())
207442cbe538SGunnar Mills     {
207542cbe538SGunnar Mills         BMCWEB_LOG_DEBUG << "Can't find PowerSupplyAttributes, no connections!";
207642cbe538SGunnar Mills         callback(inventoryItems);
207742cbe538SGunnar Mills         return;
207842cbe538SGunnar Mills     }
207942cbe538SGunnar Mills 
208042cbe538SGunnar Mills     // Assuming just one connection (service) for now
2081fe04d49cSNan Zhou     auto it = psAttributesConnections.begin();
208242cbe538SGunnar Mills 
208342cbe538SGunnar Mills     const std::string& psAttributesPath = (*it).first;
208442cbe538SGunnar Mills     const std::string& psAttributesConnection = (*it).second;
208542cbe538SGunnar Mills 
208642cbe538SGunnar Mills     // Response handler for Get DeratingFactor property
2087002d39b4SEd Tanous     auto respHandler =
2088002d39b4SEd Tanous         [sensorsAsyncResp, inventoryItems,
2089f94c4ecfSEd Tanous          callback{std::forward<Callback>(callback)}](
2090002d39b4SEd Tanous             const boost::system::error_code ec, const uint32_t value) {
209142cbe538SGunnar Mills         BMCWEB_LOG_DEBUG << "getPowerSupplyAttributesData respHandler enter";
209242cbe538SGunnar Mills         if (ec)
209342cbe538SGunnar Mills         {
209442cbe538SGunnar Mills             BMCWEB_LOG_ERROR
209542cbe538SGunnar Mills                 << "getPowerSupplyAttributesData respHandler DBus error " << ec;
20968d1b46d7Szhanghch05             messages::internalError(sensorsAsyncResp->asyncResp->res);
209742cbe538SGunnar Mills             return;
209842cbe538SGunnar Mills         }
209942cbe538SGunnar Mills 
21001e1e598dSJonathan Doman         BMCWEB_LOG_DEBUG << "PS EfficiencyPercent value: " << value;
210142cbe538SGunnar Mills         // Store value in Power Supply Inventory Items
210242cbe538SGunnar Mills         for (InventoryItem& inventoryItem : *inventoryItems)
210342cbe538SGunnar Mills         {
210455f79e6fSEd Tanous             if (inventoryItem.isPowerSupply)
210542cbe538SGunnar Mills             {
210642cbe538SGunnar Mills                 inventoryItem.powerSupplyEfficiencyPercent =
21071e1e598dSJonathan Doman                     static_cast<int>(value);
210842cbe538SGunnar Mills             }
210942cbe538SGunnar Mills         }
211042cbe538SGunnar Mills 
211142cbe538SGunnar Mills         BMCWEB_LOG_DEBUG << "getPowerSupplyAttributesData respHandler exit";
211242cbe538SGunnar Mills         callback(inventoryItems);
211342cbe538SGunnar Mills     };
211442cbe538SGunnar Mills 
211542cbe538SGunnar Mills     // Get the DeratingFactor property for the PowerSupplyAttributes
211642cbe538SGunnar Mills     // Currently only property on the interface/only one we care about
21171e1e598dSJonathan Doman     sdbusplus::asio::getProperty<uint32_t>(
21181e1e598dSJonathan Doman         *crow::connections::systemBus, psAttributesConnection, psAttributesPath,
21191e1e598dSJonathan Doman         "xyz.openbmc_project.Control.PowerSupplyAttributes", "DeratingFactor",
21201e1e598dSJonathan Doman         std::move(respHandler));
212142cbe538SGunnar Mills 
212242cbe538SGunnar Mills     BMCWEB_LOG_DEBUG << "getPowerSupplyAttributesData exit";
212342cbe538SGunnar Mills }
212442cbe538SGunnar Mills 
212542cbe538SGunnar Mills /**
212642cbe538SGunnar Mills  * @brief Gets the Power Supply Attributes such as EfficiencyPercent
212742cbe538SGunnar Mills  *
212842cbe538SGunnar Mills  * Gets the D-Bus connection (service) that provides Power Supply Attributes
212942cbe538SGunnar Mills  * data. Then gets the Power Supply Attributes data from the connection
213042cbe538SGunnar Mills  * (currently just assumes 1 connection) and stores the data in the inventory
213142cbe538SGunnar Mills  * item.
213242cbe538SGunnar Mills  *
213342cbe538SGunnar Mills  * This data is later used to provide sensor property values in the JSON
213442cbe538SGunnar Mills  * response. DeratingFactor on D-Bus is mapped to EfficiencyPercent on Redfish.
213542cbe538SGunnar Mills  *
213642cbe538SGunnar Mills  * Finds the Power Supply Attributes data asynchronously. Invokes callback
213742cbe538SGunnar Mills  * when information has been obtained.
213842cbe538SGunnar Mills  *
213942cbe538SGunnar Mills  * The callback must have the following signature:
214042cbe538SGunnar Mills  *   @code
214142cbe538SGunnar Mills  *   callback(std::shared_ptr<std::vector<InventoryItem>> inventoryItems)
214242cbe538SGunnar Mills  *   @endcode
214342cbe538SGunnar Mills  *
214442cbe538SGunnar Mills  * @param sensorsAsyncResp Pointer to object holding response data.
214542cbe538SGunnar Mills  * @param inventoryItems D-Bus inventory items associated with sensors.
214642cbe538SGunnar Mills  * @param callback Callback to invoke when data has been obtained.
214742cbe538SGunnar Mills  */
214842cbe538SGunnar Mills template <typename Callback>
214942cbe538SGunnar Mills void getPowerSupplyAttributes(
215042cbe538SGunnar Mills     std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp,
215142cbe538SGunnar Mills     std::shared_ptr<std::vector<InventoryItem>> inventoryItems,
215242cbe538SGunnar Mills     Callback&& callback)
215342cbe538SGunnar Mills {
215442cbe538SGunnar Mills     BMCWEB_LOG_DEBUG << "getPowerSupplyAttributes enter";
215542cbe538SGunnar Mills 
215642cbe538SGunnar Mills     // Only need the power supply attributes when the Power Schema
2157a0ec28b6SAdrian Ambrożewicz     if (sensorsAsyncResp->chassisSubNode != sensors::node::power)
215842cbe538SGunnar Mills     {
215942cbe538SGunnar Mills         BMCWEB_LOG_DEBUG << "getPowerSupplyAttributes exit since not Power";
216042cbe538SGunnar Mills         callback(inventoryItems);
216142cbe538SGunnar Mills         return;
216242cbe538SGunnar Mills     }
216342cbe538SGunnar Mills 
216442cbe538SGunnar Mills     const std::array<std::string, 1> interfaces = {
216542cbe538SGunnar Mills         "xyz.openbmc_project.Control.PowerSupplyAttributes"};
216642cbe538SGunnar Mills 
216742cbe538SGunnar Mills     // Response handler for parsing output from GetSubTree
2168b9d36b47SEd Tanous     auto respHandler =
2169b9d36b47SEd Tanous         [callback{std::forward<Callback>(callback)}, sensorsAsyncResp,
2170b9d36b47SEd Tanous          inventoryItems](
2171b9d36b47SEd Tanous             const boost::system::error_code ec,
2172b9d36b47SEd Tanous             const dbus::utility::MapperGetSubTreeResponse& subtree) {
217342cbe538SGunnar Mills         BMCWEB_LOG_DEBUG << "getPowerSupplyAttributes respHandler enter";
217442cbe538SGunnar Mills         if (ec)
217542cbe538SGunnar Mills         {
21768d1b46d7Szhanghch05             messages::internalError(sensorsAsyncResp->asyncResp->res);
217742cbe538SGunnar Mills             BMCWEB_LOG_ERROR
217842cbe538SGunnar Mills                 << "getPowerSupplyAttributes respHandler DBus error " << ec;
217942cbe538SGunnar Mills             return;
218042cbe538SGunnar Mills         }
218126f6976fSEd Tanous         if (subtree.empty())
218242cbe538SGunnar Mills         {
218342cbe538SGunnar Mills             BMCWEB_LOG_DEBUG << "Can't find Power Supply Attributes!";
218442cbe538SGunnar Mills             callback(inventoryItems);
218542cbe538SGunnar Mills             return;
218642cbe538SGunnar Mills         }
218742cbe538SGunnar Mills 
218842cbe538SGunnar Mills         // Currently we only support 1 power supply attribute, use this for
218942cbe538SGunnar Mills         // all the power supplies. Build map of object path to connection.
219042cbe538SGunnar Mills         // Assume just 1 connection and 1 path for now.
2191fe04d49cSNan Zhou         std::map<std::string, std::string> psAttributesConnections;
219242cbe538SGunnar Mills 
219342cbe538SGunnar Mills         if (subtree[0].first.empty() || subtree[0].second.empty())
219442cbe538SGunnar Mills         {
219542cbe538SGunnar Mills             BMCWEB_LOG_DEBUG << "Power Supply Attributes mapper error!";
219642cbe538SGunnar Mills             callback(inventoryItems);
219742cbe538SGunnar Mills             return;
219842cbe538SGunnar Mills         }
219942cbe538SGunnar Mills 
220042cbe538SGunnar Mills         const std::string& psAttributesPath = subtree[0].first;
220142cbe538SGunnar Mills         const std::string& connection = subtree[0].second.begin()->first;
220242cbe538SGunnar Mills 
220342cbe538SGunnar Mills         if (connection.empty())
220442cbe538SGunnar Mills         {
220542cbe538SGunnar Mills             BMCWEB_LOG_DEBUG << "Power Supply Attributes mapper error!";
220642cbe538SGunnar Mills             callback(inventoryItems);
220742cbe538SGunnar Mills             return;
220842cbe538SGunnar Mills         }
220942cbe538SGunnar Mills 
221042cbe538SGunnar Mills         psAttributesConnections[psAttributesPath] = connection;
221142cbe538SGunnar Mills         BMCWEB_LOG_DEBUG << "Added mapping " << psAttributesPath << " -> "
221242cbe538SGunnar Mills                          << connection;
221342cbe538SGunnar Mills 
221442cbe538SGunnar Mills         getPowerSupplyAttributesData(sensorsAsyncResp, inventoryItems,
221542cbe538SGunnar Mills                                      psAttributesConnections,
221642cbe538SGunnar Mills                                      std::move(callback));
221742cbe538SGunnar Mills         BMCWEB_LOG_DEBUG << "getPowerSupplyAttributes respHandler exit";
221842cbe538SGunnar Mills     };
221942cbe538SGunnar Mills     // Make call to ObjectMapper to find the PowerSupplyAttributes service
222042cbe538SGunnar Mills     crow::connections::systemBus->async_method_call(
222142cbe538SGunnar Mills         std::move(respHandler), "xyz.openbmc_project.ObjectMapper",
222242cbe538SGunnar Mills         "/xyz/openbmc_project/object_mapper",
222342cbe538SGunnar Mills         "xyz.openbmc_project.ObjectMapper", "GetSubTree",
222442cbe538SGunnar Mills         "/xyz/openbmc_project", 0, interfaces);
222542cbe538SGunnar Mills     BMCWEB_LOG_DEBUG << "getPowerSupplyAttributes exit";
222642cbe538SGunnar Mills }
222742cbe538SGunnar Mills 
222842cbe538SGunnar Mills /**
2229adc4f0dbSShawn McCarney  * @brief Gets inventory items associated with sensors.
22308fb49dd6SShawn McCarney  *
22318fb49dd6SShawn McCarney  * Finds the inventory items that are associated with the specified sensors.
2232adc4f0dbSShawn McCarney  * Then gets D-Bus data for the inventory items, such as presence and VPD.
22338fb49dd6SShawn McCarney  *
2234adc4f0dbSShawn McCarney  * This data is later used to provide sensor property values in the JSON
2235adc4f0dbSShawn McCarney  * response.
22368fb49dd6SShawn McCarney  *
2237adc4f0dbSShawn McCarney  * Finds the inventory items asynchronously.  Invokes callback when the
2238adc4f0dbSShawn McCarney  * inventory items have been obtained.
2239adc4f0dbSShawn McCarney  *
2240adc4f0dbSShawn McCarney  * The callback must have the following signature:
2241adc4f0dbSShawn McCarney  *   @code
2242adc4f0dbSShawn McCarney  *   callback(std::shared_ptr<std::vector<InventoryItem>> inventoryItems)
2243adc4f0dbSShawn McCarney  *   @endcode
22448fb49dd6SShawn McCarney  *
22458fb49dd6SShawn McCarney  * @param sensorsAsyncResp Pointer to object holding response data.
22468fb49dd6SShawn McCarney  * @param sensorNames All sensors within the current chassis.
22478fb49dd6SShawn McCarney  * @param objectMgrPaths Mappings from connection name to DBus object path that
22488fb49dd6SShawn McCarney  * implements ObjectManager.
2249adc4f0dbSShawn McCarney  * @param callback Callback to invoke when inventory items have been obtained.
22508fb49dd6SShawn McCarney  */
2251adc4f0dbSShawn McCarney template <typename Callback>
2252adc4f0dbSShawn McCarney static void getInventoryItems(
22538fb49dd6SShawn McCarney     std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp,
2254fe04d49cSNan Zhou     const std::shared_ptr<std::set<std::string>> sensorNames,
2255fe04d49cSNan Zhou     std::shared_ptr<std::map<std::string, std::string>> objectMgrPaths,
2256adc4f0dbSShawn McCarney     Callback&& callback)
22578fb49dd6SShawn McCarney {
2258adc4f0dbSShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItems enter";
2259adc4f0dbSShawn McCarney     auto getInventoryItemAssociationsCb =
2260f94c4ecfSEd Tanous         [sensorsAsyncResp, objectMgrPaths,
2261f94c4ecfSEd Tanous          callback{std::forward<Callback>(callback)}](
2262adc4f0dbSShawn McCarney             std::shared_ptr<std::vector<InventoryItem>> inventoryItems) {
2263adc4f0dbSShawn McCarney         BMCWEB_LOG_DEBUG << "getInventoryItemAssociationsCb enter";
22648fb49dd6SShawn McCarney         auto getInventoryItemsConnectionsCb =
2265adc4f0dbSShawn McCarney             [sensorsAsyncResp, inventoryItems, objectMgrPaths,
2266f94c4ecfSEd Tanous              callback{std::forward<const Callback>(callback)}](
2267fe04d49cSNan Zhou                 std::shared_ptr<std::set<std::string>> invConnections) {
22688fb49dd6SShawn McCarney             BMCWEB_LOG_DEBUG << "getInventoryItemsConnectionsCb enter";
2269002d39b4SEd Tanous             auto getInventoryItemsDataCb = [sensorsAsyncResp, inventoryItems,
2270d500549bSAnthony Wilson                                             callback{std::move(callback)}]() {
2271d500549bSAnthony Wilson                 BMCWEB_LOG_DEBUG << "getInventoryItemsDataCb enter";
227242cbe538SGunnar Mills 
2273002d39b4SEd Tanous                 auto getInventoryLedsCb = [sensorsAsyncResp, inventoryItems,
2274002d39b4SEd Tanous                                            callback{std::move(callback)}]() {
227542cbe538SGunnar Mills                     BMCWEB_LOG_DEBUG << "getInventoryLedsCb enter";
227642cbe538SGunnar Mills                     // Find Power Supply Attributes and get the data
2277002d39b4SEd Tanous                     getPowerSupplyAttributes(sensorsAsyncResp, inventoryItems,
227842cbe538SGunnar Mills                                              std::move(callback));
227942cbe538SGunnar Mills                     BMCWEB_LOG_DEBUG << "getInventoryLedsCb exit";
228042cbe538SGunnar Mills                 };
228142cbe538SGunnar Mills 
2282d500549bSAnthony Wilson                 // Find led connections and get the data
2283d500549bSAnthony Wilson                 getInventoryLeds(sensorsAsyncResp, inventoryItems,
228442cbe538SGunnar Mills                                  std::move(getInventoryLedsCb));
2285d500549bSAnthony Wilson                 BMCWEB_LOG_DEBUG << "getInventoryItemsDataCb exit";
2286d500549bSAnthony Wilson             };
22878fb49dd6SShawn McCarney 
2288adc4f0dbSShawn McCarney             // Get inventory item data from connections
2289adc4f0dbSShawn McCarney             getInventoryItemsData(sensorsAsyncResp, inventoryItems,
2290adc4f0dbSShawn McCarney                                   invConnections, objectMgrPaths,
2291d500549bSAnthony Wilson                                   std::move(getInventoryItemsDataCb));
22928fb49dd6SShawn McCarney             BMCWEB_LOG_DEBUG << "getInventoryItemsConnectionsCb exit";
22938fb49dd6SShawn McCarney         };
22948fb49dd6SShawn McCarney 
2295adc4f0dbSShawn McCarney         // Get connections that provide inventory item data
2296002d39b4SEd Tanous         getInventoryItemsConnections(sensorsAsyncResp, inventoryItems,
22978fb49dd6SShawn McCarney                                      std::move(getInventoryItemsConnectionsCb));
2298adc4f0dbSShawn McCarney         BMCWEB_LOG_DEBUG << "getInventoryItemAssociationsCb exit";
22998fb49dd6SShawn McCarney     };
23008fb49dd6SShawn McCarney 
2301adc4f0dbSShawn McCarney     // Get associations from sensors to inventory items
2302adc4f0dbSShawn McCarney     getInventoryItemAssociations(sensorsAsyncResp, sensorNames, objectMgrPaths,
2303adc4f0dbSShawn McCarney                                  std::move(getInventoryItemAssociationsCb));
2304adc4f0dbSShawn McCarney     BMCWEB_LOG_DEBUG << "getInventoryItems exit";
2305adc4f0dbSShawn McCarney }
2306adc4f0dbSShawn McCarney 
2307adc4f0dbSShawn McCarney /**
2308adc4f0dbSShawn McCarney  * @brief Returns JSON PowerSupply object for the specified inventory item.
2309adc4f0dbSShawn McCarney  *
2310adc4f0dbSShawn McCarney  * Searches for a JSON PowerSupply object that matches the specified inventory
2311adc4f0dbSShawn McCarney  * item.  If one is not found, a new PowerSupply object is added to the JSON
2312adc4f0dbSShawn McCarney  * array.
2313adc4f0dbSShawn McCarney  *
2314adc4f0dbSShawn McCarney  * Multiple sensors are often associated with one power supply inventory item.
2315adc4f0dbSShawn McCarney  * As a result, multiple sensor values are stored in one JSON PowerSupply
2316adc4f0dbSShawn McCarney  * object.
2317adc4f0dbSShawn McCarney  *
2318adc4f0dbSShawn McCarney  * @param powerSupplyArray JSON array containing Redfish PowerSupply objects.
2319adc4f0dbSShawn McCarney  * @param inventoryItem Inventory item for the power supply.
2320adc4f0dbSShawn McCarney  * @param chassisId Chassis that contains the power supply.
2321adc4f0dbSShawn McCarney  * @return JSON PowerSupply object for the specified inventory item.
2322adc4f0dbSShawn McCarney  */
232323a21a1cSEd Tanous inline nlohmann::json& getPowerSupply(nlohmann::json& powerSupplyArray,
2324adc4f0dbSShawn McCarney                                       const InventoryItem& inventoryItem,
2325adc4f0dbSShawn McCarney                                       const std::string& chassisId)
2326adc4f0dbSShawn McCarney {
2327adc4f0dbSShawn McCarney     // Check if matching PowerSupply object already exists in JSON array
2328adc4f0dbSShawn McCarney     for (nlohmann::json& powerSupply : powerSupplyArray)
2329adc4f0dbSShawn McCarney     {
2330adc4f0dbSShawn McCarney         if (powerSupply["MemberId"] == inventoryItem.name)
2331adc4f0dbSShawn McCarney         {
2332adc4f0dbSShawn McCarney             return powerSupply;
2333adc4f0dbSShawn McCarney         }
2334adc4f0dbSShawn McCarney     }
2335adc4f0dbSShawn McCarney 
2336adc4f0dbSShawn McCarney     // Add new PowerSupply object to JSON array
2337adc4f0dbSShawn McCarney     powerSupplyArray.push_back({});
2338adc4f0dbSShawn McCarney     nlohmann::json& powerSupply = powerSupplyArray.back();
2339adc4f0dbSShawn McCarney     powerSupply["@odata.id"] =
2340adc4f0dbSShawn McCarney         "/redfish/v1/Chassis/" + chassisId + "/Power#/PowerSupplies/";
2341adc4f0dbSShawn McCarney     powerSupply["MemberId"] = inventoryItem.name;
2342adc4f0dbSShawn McCarney     powerSupply["Name"] = boost::replace_all_copy(inventoryItem.name, "_", " ");
2343adc4f0dbSShawn McCarney     powerSupply["Manufacturer"] = inventoryItem.manufacturer;
2344adc4f0dbSShawn McCarney     powerSupply["Model"] = inventoryItem.model;
2345adc4f0dbSShawn McCarney     powerSupply["PartNumber"] = inventoryItem.partNumber;
2346adc4f0dbSShawn McCarney     powerSupply["SerialNumber"] = inventoryItem.serialNumber;
2347d500549bSAnthony Wilson     setLedState(powerSupply, &inventoryItem);
2348adc4f0dbSShawn McCarney 
234942cbe538SGunnar Mills     if (inventoryItem.powerSupplyEfficiencyPercent >= 0)
235042cbe538SGunnar Mills     {
235142cbe538SGunnar Mills         powerSupply["EfficiencyPercent"] =
235242cbe538SGunnar Mills             inventoryItem.powerSupplyEfficiencyPercent;
235342cbe538SGunnar Mills     }
235442cbe538SGunnar Mills 
235542cbe538SGunnar Mills     powerSupply["Status"]["State"] = getState(&inventoryItem);
2356adc4f0dbSShawn McCarney     const char* health = inventoryItem.isFunctional ? "OK" : "Critical";
2357adc4f0dbSShawn McCarney     powerSupply["Status"]["Health"] = health;
2358adc4f0dbSShawn McCarney 
2359adc4f0dbSShawn McCarney     return powerSupply;
23608fb49dd6SShawn McCarney }
23618fb49dd6SShawn McCarney 
23628fb49dd6SShawn McCarney /**
2363de629b6eSShawn McCarney  * @brief Gets the values of the specified sensors.
2364de629b6eSShawn McCarney  *
2365de629b6eSShawn McCarney  * Stores the results as JSON in the SensorsAsyncResp.
2366de629b6eSShawn McCarney  *
2367de629b6eSShawn McCarney  * Gets the sensor values asynchronously.  Stores the results later when the
2368de629b6eSShawn McCarney  * information has been obtained.
2369de629b6eSShawn McCarney  *
2370adc4f0dbSShawn McCarney  * The sensorNames set contains all requested sensors for the current chassis.
2371de629b6eSShawn McCarney  *
2372de629b6eSShawn McCarney  * To minimize the number of DBus calls, the DBus method
2373de629b6eSShawn McCarney  * org.freedesktop.DBus.ObjectManager.GetManagedObjects() is used to get the
2374de629b6eSShawn McCarney  * values of all sensors provided by a connection (service).
2375de629b6eSShawn McCarney  *
2376de629b6eSShawn McCarney  * The connections set contains all the connections that provide sensor values.
2377de629b6eSShawn McCarney  *
2378de629b6eSShawn McCarney  * The objectMgrPaths map contains mappings from a connection name to the
2379de629b6eSShawn McCarney  * corresponding DBus object path that implements ObjectManager.
2380de629b6eSShawn McCarney  *
2381adc4f0dbSShawn McCarney  * The InventoryItem vector contains D-Bus inventory items associated with the
2382adc4f0dbSShawn McCarney  * sensors.  Inventory item data is needed for some Redfish sensor properties.
2383adc4f0dbSShawn McCarney  *
2384de629b6eSShawn McCarney  * @param SensorsAsyncResp Pointer to object holding response data.
2385adc4f0dbSShawn McCarney  * @param sensorNames All requested sensors within the current chassis.
2386de629b6eSShawn McCarney  * @param connections Connections that provide sensor values.
2387de629b6eSShawn McCarney  * @param objectMgrPaths Mappings from connection name to DBus object path that
2388de629b6eSShawn McCarney  * implements ObjectManager.
2389adc4f0dbSShawn McCarney  * @param inventoryItems Inventory items associated with the sensors.
2390de629b6eSShawn McCarney  */
239123a21a1cSEd Tanous inline void getSensorData(
239281ce609eSEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
2393fe04d49cSNan Zhou     const std::shared_ptr<std::set<std::string>>& sensorNames,
2394fe04d49cSNan Zhou     const std::set<std::string>& connections,
2395fe04d49cSNan Zhou     const std::shared_ptr<std::map<std::string, std::string>>& objectMgrPaths,
2396b5a76932SEd Tanous     const std::shared_ptr<std::vector<InventoryItem>>& inventoryItems)
2397de629b6eSShawn McCarney {
2398de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getSensorData enter";
2399de629b6eSShawn McCarney     // Get managed objects from all services exposing sensors
2400de629b6eSShawn McCarney     for (const std::string& connection : connections)
2401de629b6eSShawn McCarney     {
2402de629b6eSShawn McCarney         // Response handler to process managed objects
2403002d39b4SEd Tanous         auto getManagedObjectsCb =
2404002d39b4SEd Tanous             [sensorsAsyncResp, sensorNames,
2405002d39b4SEd Tanous              inventoryItems](const boost::system::error_code ec,
240602cad96eSEd Tanous                              const dbus::utility::ManagedObjectType& resp) {
2407de629b6eSShawn McCarney             BMCWEB_LOG_DEBUG << "getManagedObjectsCb enter";
2408de629b6eSShawn McCarney             if (ec)
2409de629b6eSShawn McCarney             {
2410de629b6eSShawn McCarney                 BMCWEB_LOG_ERROR << "getManagedObjectsCb DBUS error: " << ec;
24118d1b46d7Szhanghch05                 messages::internalError(sensorsAsyncResp->asyncResp->res);
2412de629b6eSShawn McCarney                 return;
2413de629b6eSShawn McCarney             }
2414de629b6eSShawn McCarney             // Go through all objects and update response with sensor data
2415de629b6eSShawn McCarney             for (const auto& objDictEntry : resp)
2416de629b6eSShawn McCarney             {
2417de629b6eSShawn McCarney                 const std::string& objPath =
2418de629b6eSShawn McCarney                     static_cast<const std::string&>(objDictEntry.first);
2419de629b6eSShawn McCarney                 BMCWEB_LOG_DEBUG << "getManagedObjectsCb parsing object "
2420de629b6eSShawn McCarney                                  << objPath;
2421de629b6eSShawn McCarney 
2422de629b6eSShawn McCarney                 std::vector<std::string> split;
2423de629b6eSShawn McCarney                 // Reserve space for
2424de629b6eSShawn McCarney                 // /xyz/openbmc_project/sensors/<name>/<subname>
2425de629b6eSShawn McCarney                 split.reserve(6);
2426de629b6eSShawn McCarney                 boost::algorithm::split(split, objPath, boost::is_any_of("/"));
2427de629b6eSShawn McCarney                 if (split.size() < 6)
2428de629b6eSShawn McCarney                 {
2429de629b6eSShawn McCarney                     BMCWEB_LOG_ERROR << "Got path that isn't long enough "
2430de629b6eSShawn McCarney                                      << objPath;
2431de629b6eSShawn McCarney                     continue;
2432de629b6eSShawn McCarney                 }
2433de629b6eSShawn McCarney                 // These indexes aren't intuitive, as boost::split puts an empty
2434de629b6eSShawn McCarney                 // string at the beginning
2435de629b6eSShawn McCarney                 const std::string& sensorType = split[4];
2436de629b6eSShawn McCarney                 const std::string& sensorName = split[5];
2437de629b6eSShawn McCarney                 BMCWEB_LOG_DEBUG << "sensorName " << sensorName
2438de629b6eSShawn McCarney                                  << " sensorType " << sensorType;
243949c53ac9SJohnathan Mantey                 if (sensorNames->find(objPath) == sensorNames->end())
2440de629b6eSShawn McCarney                 {
2441accdbb2cSAndrew Geissler                     BMCWEB_LOG_DEBUG << sensorName << " not in sensor list ";
2442de629b6eSShawn McCarney                     continue;
2443de629b6eSShawn McCarney                 }
2444de629b6eSShawn McCarney 
2445adc4f0dbSShawn McCarney                 // Find inventory item (if any) associated with sensor
2446adc4f0dbSShawn McCarney                 InventoryItem* inventoryItem =
2447adc4f0dbSShawn McCarney                     findInventoryItemForSensor(inventoryItems, objPath);
2448adc4f0dbSShawn McCarney 
244995a3ecadSAnthony Wilson                 const std::string& sensorSchema =
245081ce609eSEd Tanous                     sensorsAsyncResp->chassisSubNode;
245195a3ecadSAnthony Wilson 
245295a3ecadSAnthony Wilson                 nlohmann::json* sensorJson = nullptr;
245395a3ecadSAnthony Wilson 
2454928fefb9SNan Zhou                 if (sensorSchema == sensors::node::sensors &&
2455928fefb9SNan Zhou                     !sensorsAsyncResp->efficientExpand)
245695a3ecadSAnthony Wilson                 {
2457c1d019a6SEd Tanous                     std::string sensorTypeEscaped(sensorType);
2458c1d019a6SEd Tanous                     sensorTypeEscaped.erase(
2459c1d019a6SEd Tanous                         std::remove(sensorTypeEscaped.begin(),
2460c1d019a6SEd Tanous                                     sensorTypeEscaped.end(), '_'),
2461c1d019a6SEd Tanous                         sensorTypeEscaped.end());
2462c1d019a6SEd Tanous                     std::string sensorId(sensorTypeEscaped);
2463c1d019a6SEd Tanous                     sensorId += "_";
2464c1d019a6SEd Tanous                     sensorId += sensorName;
2465c1d019a6SEd Tanous 
24668d1b46d7Szhanghch05                     sensorsAsyncResp->asyncResp->res.jsonValue["@odata.id"] =
2467c1d019a6SEd Tanous                         crow::utility::urlFromPieces(
2468c1d019a6SEd Tanous                             "redfish", "v1", "Chassis",
2469c1d019a6SEd Tanous                             sensorsAsyncResp->chassisId,
2470c1d019a6SEd Tanous                             sensorsAsyncResp->chassisSubNode, sensorId);
24718d1b46d7Szhanghch05                     sensorJson = &(sensorsAsyncResp->asyncResp->res.jsonValue);
247295a3ecadSAnthony Wilson                 }
247395a3ecadSAnthony Wilson                 else
247495a3ecadSAnthony Wilson                 {
2475271584abSEd Tanous                     std::string fieldName;
2476928fefb9SNan Zhou                     if (sensorsAsyncResp->efficientExpand)
2477928fefb9SNan Zhou                     {
2478928fefb9SNan Zhou                         fieldName = "Members";
2479928fefb9SNan Zhou                     }
2480928fefb9SNan Zhou                     else if (sensorType == "temperature")
2481de629b6eSShawn McCarney                     {
2482de629b6eSShawn McCarney                         fieldName = "Temperatures";
2483de629b6eSShawn McCarney                     }
2484de629b6eSShawn McCarney                     else if (sensorType == "fan" || sensorType == "fan_tach" ||
2485de629b6eSShawn McCarney                              sensorType == "fan_pwm")
2486de629b6eSShawn McCarney                     {
2487de629b6eSShawn McCarney                         fieldName = "Fans";
2488de629b6eSShawn McCarney                     }
2489de629b6eSShawn McCarney                     else if (sensorType == "voltage")
2490de629b6eSShawn McCarney                     {
2491de629b6eSShawn McCarney                         fieldName = "Voltages";
2492de629b6eSShawn McCarney                     }
2493de629b6eSShawn McCarney                     else if (sensorType == "power")
2494de629b6eSShawn McCarney                     {
249555f79e6fSEd Tanous                         if (sensorName == "total_power")
2496028f7ebcSEddie James                         {
2497028f7ebcSEddie James                             fieldName = "PowerControl";
2498028f7ebcSEddie James                         }
2499adc4f0dbSShawn McCarney                         else if ((inventoryItem != nullptr) &&
2500adc4f0dbSShawn McCarney                                  (inventoryItem->isPowerSupply))
2501028f7ebcSEddie James                         {
2502de629b6eSShawn McCarney                             fieldName = "PowerSupplies";
2503de629b6eSShawn McCarney                         }
2504adc4f0dbSShawn McCarney                         else
2505adc4f0dbSShawn McCarney                         {
2506adc4f0dbSShawn McCarney                             // Other power sensors are in SensorCollection
2507adc4f0dbSShawn McCarney                             continue;
2508adc4f0dbSShawn McCarney                         }
2509028f7ebcSEddie James                     }
2510de629b6eSShawn McCarney                     else
2511de629b6eSShawn McCarney                     {
2512de629b6eSShawn McCarney                         BMCWEB_LOG_ERROR << "Unsure how to handle sensorType "
2513de629b6eSShawn McCarney                                          << sensorType;
2514de629b6eSShawn McCarney                         continue;
2515de629b6eSShawn McCarney                     }
2516de629b6eSShawn McCarney 
2517de629b6eSShawn McCarney                     nlohmann::json& tempArray =
25188d1b46d7Szhanghch05                         sensorsAsyncResp->asyncResp->res.jsonValue[fieldName];
2519adc4f0dbSShawn McCarney                     if (fieldName == "PowerControl")
252049c53ac9SJohnathan Mantey                     {
2521adc4f0dbSShawn McCarney                         if (tempArray.empty())
25227ab06f49SGunnar Mills                         {
252395a3ecadSAnthony Wilson                             // Put multiple "sensors" into a single
252495a3ecadSAnthony Wilson                             // PowerControl. Follows MemberId naming and
252595a3ecadSAnthony Wilson                             // naming in power.hpp.
25261476687dSEd Tanous                             nlohmann::json::object_t power;
25271476687dSEd Tanous                             power["@odata.id"] =
2528adc4f0dbSShawn McCarney                                 "/redfish/v1/Chassis/" +
252981ce609eSEd Tanous                                 sensorsAsyncResp->chassisId + "/" +
253081ce609eSEd Tanous                                 sensorsAsyncResp->chassisSubNode + "#/" +
25311476687dSEd Tanous                                 fieldName + "/0";
25321476687dSEd Tanous                             tempArray.push_back(std::move(power));
2533adc4f0dbSShawn McCarney                         }
2534adc4f0dbSShawn McCarney                         sensorJson = &(tempArray.back());
2535adc4f0dbSShawn McCarney                     }
2536adc4f0dbSShawn McCarney                     else if (fieldName == "PowerSupplies")
2537adc4f0dbSShawn McCarney                     {
2538adc4f0dbSShawn McCarney                         if (inventoryItem != nullptr)
2539adc4f0dbSShawn McCarney                         {
2540adc4f0dbSShawn McCarney                             sensorJson =
2541adc4f0dbSShawn McCarney                                 &(getPowerSupply(tempArray, *inventoryItem,
254281ce609eSEd Tanous                                                  sensorsAsyncResp->chassisId));
2543adc4f0dbSShawn McCarney                         }
254449c53ac9SJohnathan Mantey                     }
2545928fefb9SNan Zhou                     else if (fieldName == "Members")
2546928fefb9SNan Zhou                     {
25471476687dSEd Tanous                         nlohmann::json::object_t member;
25481476687dSEd Tanous                         member["@odata.id"] =
2549928fefb9SNan Zhou                             "/redfish/v1/Chassis/" +
2550928fefb9SNan Zhou                             sensorsAsyncResp->chassisId + "/" +
25511476687dSEd Tanous                             sensorsAsyncResp->chassisSubNode + "/" + sensorName;
25521476687dSEd Tanous                         tempArray.push_back(std::move(member));
2553928fefb9SNan Zhou                         sensorJson = &(tempArray.back());
2554928fefb9SNan Zhou                     }
255549c53ac9SJohnathan Mantey                     else
255649c53ac9SJohnathan Mantey                     {
25571476687dSEd Tanous                         nlohmann::json::object_t member;
25581476687dSEd Tanous                         member["@odata.id"] = "/redfish/v1/Chassis/" +
25591476687dSEd Tanous                                               sensorsAsyncResp->chassisId +
25601476687dSEd Tanous                                               "/" +
25611476687dSEd Tanous                                               sensorsAsyncResp->chassisSubNode +
25621476687dSEd Tanous                                               "#/" + fieldName + "/";
25631476687dSEd Tanous                         tempArray.push_back(std::move(member));
2564adc4f0dbSShawn McCarney                         sensorJson = &(tempArray.back());
256549c53ac9SJohnathan Mantey                     }
256695a3ecadSAnthony Wilson                 }
2567de629b6eSShawn McCarney 
2568adc4f0dbSShawn McCarney                 if (sensorJson != nullptr)
2569adc4f0dbSShawn McCarney                 {
25701d7c0054SEd Tanous                     objectInterfacesToJson(sensorName, sensorType,
25711d7c0054SEd Tanous                                            sensorsAsyncResp->chassisSubNode,
25721d7c0054SEd Tanous                                            objDictEntry.second, *sensorJson,
25731d7c0054SEd Tanous                                            inventoryItem);
25741d7c0054SEd Tanous 
25751d7c0054SEd Tanous                     std::string path = "/xyz/openbmc_project/sensors/";
25761d7c0054SEd Tanous                     path += sensorType;
25771d7c0054SEd Tanous                     path += "/";
25781d7c0054SEd Tanous                     path += sensorName;
2579c1d019a6SEd Tanous                     sensorsAsyncResp->addMetadata(*sensorJson, path);
2580adc4f0dbSShawn McCarney                 }
2581de629b6eSShawn McCarney             }
258281ce609eSEd Tanous             if (sensorsAsyncResp.use_count() == 1)
258349c53ac9SJohnathan Mantey             {
258481ce609eSEd Tanous                 sortJSONResponse(sensorsAsyncResp);
2585928fefb9SNan Zhou                 if (sensorsAsyncResp->chassisSubNode ==
2586928fefb9SNan Zhou                         sensors::node::sensors &&
2587928fefb9SNan Zhou                     sensorsAsyncResp->efficientExpand)
2588928fefb9SNan Zhou                 {
2589928fefb9SNan Zhou                     sensorsAsyncResp->asyncResp->res
2590928fefb9SNan Zhou                         .jsonValue["Members@odata.count"] =
2591928fefb9SNan Zhou                         sensorsAsyncResp->asyncResp->res.jsonValue["Members"]
2592928fefb9SNan Zhou                             .size();
2593928fefb9SNan Zhou                 }
2594928fefb9SNan Zhou                 else if (sensorsAsyncResp->chassisSubNode ==
2595928fefb9SNan Zhou                          sensors::node::thermal)
25968bd25ccdSJames Feist                 {
259781ce609eSEd Tanous                     populateFanRedundancy(sensorsAsyncResp);
25988bd25ccdSJames Feist                 }
259949c53ac9SJohnathan Mantey             }
2600de629b6eSShawn McCarney             BMCWEB_LOG_DEBUG << "getManagedObjectsCb exit";
2601de629b6eSShawn McCarney         };
2602de629b6eSShawn McCarney 
2603de629b6eSShawn McCarney         // Find DBus object path that implements ObjectManager for the current
2604de629b6eSShawn McCarney         // connection.  If no mapping found, default to "/".
26058fb49dd6SShawn McCarney         auto iter = objectMgrPaths->find(connection);
2606de629b6eSShawn McCarney         const std::string& objectMgrPath =
26078fb49dd6SShawn McCarney             (iter != objectMgrPaths->end()) ? iter->second : "/";
2608de629b6eSShawn McCarney         BMCWEB_LOG_DEBUG << "ObjectManager path for " << connection << " is "
2609de629b6eSShawn McCarney                          << objectMgrPath;
2610de629b6eSShawn McCarney 
2611de629b6eSShawn McCarney         crow::connections::systemBus->async_method_call(
2612de629b6eSShawn McCarney             getManagedObjectsCb, connection, objectMgrPath,
2613de629b6eSShawn McCarney             "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
261423a21a1cSEd Tanous     }
2615de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getSensorData exit";
2616de629b6eSShawn McCarney }
2617de629b6eSShawn McCarney 
2618fe04d49cSNan Zhou inline void
2619fe04d49cSNan Zhou     processSensorList(const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
2620fe04d49cSNan Zhou                       const std::shared_ptr<std::set<std::string>>& sensorNames)
26211abe55efSEd Tanous {
2622fe04d49cSNan Zhou     auto getConnectionCb = [sensorsAsyncResp, sensorNames](
2623fe04d49cSNan Zhou                                const std::set<std::string>& connections) {
262455c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "getConnectionCb enter";
2625de629b6eSShawn McCarney         auto getObjectManagerPathsCb =
2626fe04d49cSNan Zhou             [sensorsAsyncResp, sensorNames, connections](
2627fe04d49cSNan Zhou                 const std::shared_ptr<std::map<std::string, std::string>>&
2628fe04d49cSNan Zhou                     objectMgrPaths) {
2629de629b6eSShawn McCarney             BMCWEB_LOG_DEBUG << "getObjectManagerPathsCb enter";
2630adc4f0dbSShawn McCarney             auto getInventoryItemsCb =
2631002d39b4SEd Tanous                 [sensorsAsyncResp, sensorNames, connections, objectMgrPaths](
2632f23b7296SEd Tanous                     const std::shared_ptr<std::vector<InventoryItem>>&
2633adc4f0dbSShawn McCarney                         inventoryItems) {
2634adc4f0dbSShawn McCarney                 BMCWEB_LOG_DEBUG << "getInventoryItemsCb enter";
263549c53ac9SJohnathan Mantey                 // Get sensor data and store results in JSON
2636002d39b4SEd Tanous                 getSensorData(sensorsAsyncResp, sensorNames, connections,
2637002d39b4SEd Tanous                               objectMgrPaths, inventoryItems);
2638adc4f0dbSShawn McCarney                 BMCWEB_LOG_DEBUG << "getInventoryItemsCb exit";
2639adc4f0dbSShawn McCarney             };
2640adc4f0dbSShawn McCarney 
2641adc4f0dbSShawn McCarney             // Get inventory items associated with sensors
2642002d39b4SEd Tanous             getInventoryItems(sensorsAsyncResp, sensorNames, objectMgrPaths,
2643adc4f0dbSShawn McCarney                               std::move(getInventoryItemsCb));
2644adc4f0dbSShawn McCarney 
2645de629b6eSShawn McCarney             BMCWEB_LOG_DEBUG << "getObjectManagerPathsCb exit";
264608777fb0SLewanczyk, Dawid         };
2647de629b6eSShawn McCarney 
264849c53ac9SJohnathan Mantey         // Get mapping from connection names to the DBus object
264949c53ac9SJohnathan Mantey         // paths that implement the ObjectManager interface
265081ce609eSEd Tanous         getObjectManagerPaths(sensorsAsyncResp,
2651de629b6eSShawn McCarney                               std::move(getObjectManagerPathsCb));
265255c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "getConnectionCb exit";
265308777fb0SLewanczyk, Dawid     };
2654de629b6eSShawn McCarney 
2655de629b6eSShawn McCarney     // Get set of connections that provide sensor values
265681ce609eSEd Tanous     getConnections(sensorsAsyncResp, sensorNames, std::move(getConnectionCb));
265795a3ecadSAnthony Wilson }
265895a3ecadSAnthony Wilson 
265995a3ecadSAnthony Wilson /**
266095a3ecadSAnthony Wilson  * @brief Entry point for retrieving sensors data related to requested
266195a3ecadSAnthony Wilson  *        chassis.
266295a3ecadSAnthony Wilson  * @param SensorsAsyncResp   Pointer to object holding response data
266395a3ecadSAnthony Wilson  */
2664b5a76932SEd Tanous inline void
266581ce609eSEd Tanous     getChassisData(const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp)
266695a3ecadSAnthony Wilson {
266795a3ecadSAnthony Wilson     BMCWEB_LOG_DEBUG << "getChassisData enter";
266895a3ecadSAnthony Wilson     auto getChassisCb =
266981ce609eSEd Tanous         [sensorsAsyncResp](
2670fe04d49cSNan Zhou             const std::shared_ptr<std::set<std::string>>& sensorNames) {
267195a3ecadSAnthony Wilson         BMCWEB_LOG_DEBUG << "getChassisCb enter";
267281ce609eSEd Tanous         processSensorList(sensorsAsyncResp, sensorNames);
267355c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "getChassisCb exit";
267408777fb0SLewanczyk, Dawid     };
2675928fefb9SNan Zhou     // SensorCollection doesn't contain the Redundancy property
2676928fefb9SNan Zhou     if (sensorsAsyncResp->chassisSubNode != sensors::node::sensors)
2677928fefb9SNan Zhou     {
26788d1b46d7Szhanghch05         sensorsAsyncResp->asyncResp->res.jsonValue["Redundancy"] =
26798d1b46d7Szhanghch05             nlohmann::json::array();
2680928fefb9SNan Zhou     }
268126f03899SShawn McCarney     // Get set of sensors in chassis
26827f1cc26dSEd Tanous     getChassis(sensorsAsyncResp->asyncResp, sensorsAsyncResp->chassisId,
26837f1cc26dSEd Tanous                sensorsAsyncResp->chassisSubNode, sensorsAsyncResp->types,
26847f1cc26dSEd Tanous                std::move(getChassisCb));
268555c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "getChassisData exit";
2686271584abSEd Tanous }
268708777fb0SLewanczyk, Dawid 
2688413961deSRichard Marian Thomaiyar /**
268949c53ac9SJohnathan Mantey  * @brief Find the requested sensorName in the list of all sensors supplied by
269049c53ac9SJohnathan Mantey  * the chassis node
269149c53ac9SJohnathan Mantey  *
269249c53ac9SJohnathan Mantey  * @param sensorName   The sensor name supplied in the PATCH request
269349c53ac9SJohnathan Mantey  * @param sensorsList  The list of sensors managed by the chassis node
269449c53ac9SJohnathan Mantey  * @param sensorsModified  The list of sensors that were found as a result of
269549c53ac9SJohnathan Mantey  *                         repeated calls to this function
269649c53ac9SJohnathan Mantey  */
2697fe04d49cSNan Zhou inline bool
2698fe04d49cSNan Zhou     findSensorNameUsingSensorPath(std::string_view sensorName,
269902cad96eSEd Tanous                                   const std::set<std::string>& sensorsList,
2700fe04d49cSNan Zhou                                   std::set<std::string>& sensorsModified)
270149c53ac9SJohnathan Mantey {
2702fe04d49cSNan Zhou     for (const auto& chassisSensor : sensorsList)
270349c53ac9SJohnathan Mantey     {
270428aa8de5SGeorge Liu         sdbusplus::message::object_path path(chassisSensor);
2705b00dcc27SEd Tanous         std::string thisSensorName = path.filename();
270628aa8de5SGeorge Liu         if (thisSensorName.empty())
270749c53ac9SJohnathan Mantey         {
270849c53ac9SJohnathan Mantey             continue;
270949c53ac9SJohnathan Mantey         }
271049c53ac9SJohnathan Mantey         if (thisSensorName == sensorName)
271149c53ac9SJohnathan Mantey         {
271249c53ac9SJohnathan Mantey             sensorsModified.emplace(chassisSensor);
271349c53ac9SJohnathan Mantey             return true;
271449c53ac9SJohnathan Mantey         }
271549c53ac9SJohnathan Mantey     }
271649c53ac9SJohnathan Mantey     return false;
271749c53ac9SJohnathan Mantey }
271849c53ac9SJohnathan Mantey 
271949c53ac9SJohnathan Mantey /**
2720413961deSRichard Marian Thomaiyar  * @brief Entry point for overriding sensor values of given sensor
2721413961deSRichard Marian Thomaiyar  *
27228d1b46d7Szhanghch05  * @param sensorAsyncResp   response object
27234bb3dc34SCarol Wang  * @param allCollections   Collections extract from sensors' request patch info
2724413961deSRichard Marian Thomaiyar  * @param chassisSubNode   Chassis Node for which the query has to happen
2725413961deSRichard Marian Thomaiyar  */
272623a21a1cSEd Tanous inline void setSensorsOverride(
2727b5a76932SEd Tanous     const std::shared_ptr<SensorsAsyncResp>& sensorAsyncResp,
27284bb3dc34SCarol Wang     std::unordered_map<std::string, std::vector<nlohmann::json>>&
2729397fd61fSjayaprakash Mutyala         allCollections)
2730413961deSRichard Marian Thomaiyar {
273170d1d0aaSjayaprakash Mutyala     BMCWEB_LOG_INFO << "setSensorsOverride for subNode"
27324bb3dc34SCarol Wang                     << sensorAsyncResp->chassisSubNode << "\n";
2733413961deSRichard Marian Thomaiyar 
2734543f4400SEd Tanous     const char* propertyValueName = nullptr;
2735f65af9e8SRichard Marian Thomaiyar     std::unordered_map<std::string, std::pair<double, std::string>> overrideMap;
2736413961deSRichard Marian Thomaiyar     std::string memberId;
2737543f4400SEd Tanous     double value = 0.0;
2738f65af9e8SRichard Marian Thomaiyar     for (auto& collectionItems : allCollections)
2739f65af9e8SRichard Marian Thomaiyar     {
2740f65af9e8SRichard Marian Thomaiyar         if (collectionItems.first == "Temperatures")
2741f65af9e8SRichard Marian Thomaiyar         {
2742f65af9e8SRichard Marian Thomaiyar             propertyValueName = "ReadingCelsius";
2743f65af9e8SRichard Marian Thomaiyar         }
2744f65af9e8SRichard Marian Thomaiyar         else if (collectionItems.first == "Fans")
2745f65af9e8SRichard Marian Thomaiyar         {
2746f65af9e8SRichard Marian Thomaiyar             propertyValueName = "Reading";
2747f65af9e8SRichard Marian Thomaiyar         }
2748f65af9e8SRichard Marian Thomaiyar         else
2749f65af9e8SRichard Marian Thomaiyar         {
2750f65af9e8SRichard Marian Thomaiyar             propertyValueName = "ReadingVolts";
2751f65af9e8SRichard Marian Thomaiyar         }
2752f65af9e8SRichard Marian Thomaiyar         for (auto& item : collectionItems.second)
2753f65af9e8SRichard Marian Thomaiyar         {
27548d1b46d7Szhanghch05             if (!json_util::readJson(item, sensorAsyncResp->asyncResp->res,
27558d1b46d7Szhanghch05                                      "MemberId", memberId, propertyValueName,
27568d1b46d7Szhanghch05                                      value))
2757413961deSRichard Marian Thomaiyar             {
2758413961deSRichard Marian Thomaiyar                 return;
2759413961deSRichard Marian Thomaiyar             }
2760f65af9e8SRichard Marian Thomaiyar             overrideMap.emplace(memberId,
2761f65af9e8SRichard Marian Thomaiyar                                 std::make_pair(value, collectionItems.first));
2762f65af9e8SRichard Marian Thomaiyar         }
2763f65af9e8SRichard Marian Thomaiyar     }
27644bb3dc34SCarol Wang 
2765002d39b4SEd Tanous     auto getChassisSensorListCb =
2766002d39b4SEd Tanous         [sensorAsyncResp, overrideMap](
2767fe04d49cSNan Zhou             const std::shared_ptr<std::set<std::string>>& sensorsList) {
276849c53ac9SJohnathan Mantey         // Match sensor names in the PATCH request to those managed by the
276949c53ac9SJohnathan Mantey         // chassis node
2770fe04d49cSNan Zhou         const std::shared_ptr<std::set<std::string>> sensorNames =
2771fe04d49cSNan Zhou             std::make_shared<std::set<std::string>>();
2772f65af9e8SRichard Marian Thomaiyar         for (const auto& item : overrideMap)
2773413961deSRichard Marian Thomaiyar         {
2774f65af9e8SRichard Marian Thomaiyar             const auto& sensor = item.first;
277549c53ac9SJohnathan Mantey             if (!findSensorNameUsingSensorPath(sensor, *sensorsList,
277649c53ac9SJohnathan Mantey                                                *sensorNames))
2777f65af9e8SRichard Marian Thomaiyar             {
2778f65af9e8SRichard Marian Thomaiyar                 BMCWEB_LOG_INFO << "Unable to find memberId " << item.first;
27798d1b46d7Szhanghch05                 messages::resourceNotFound(sensorAsyncResp->asyncResp->res,
2780f65af9e8SRichard Marian Thomaiyar                                            item.second.second, item.first);
2781413961deSRichard Marian Thomaiyar                 return;
2782413961deSRichard Marian Thomaiyar             }
2783f65af9e8SRichard Marian Thomaiyar         }
2784413961deSRichard Marian Thomaiyar         // Get the connection to which the memberId belongs
2785002d39b4SEd Tanous         auto getObjectsWithConnectionCb =
2786fe04d49cSNan Zhou             [sensorAsyncResp,
2787fe04d49cSNan Zhou              overrideMap](const std::set<std::string>& /*connections*/,
2788002d39b4SEd Tanous                           const std::set<std::pair<std::string, std::string>>&
2789413961deSRichard Marian Thomaiyar                               objectsWithConnection) {
2790f65af9e8SRichard Marian Thomaiyar             if (objectsWithConnection.size() != overrideMap.size())
2791413961deSRichard Marian Thomaiyar             {
2792413961deSRichard Marian Thomaiyar                 BMCWEB_LOG_INFO
2793f65af9e8SRichard Marian Thomaiyar                     << "Unable to find all objects with proper connection "
2794f65af9e8SRichard Marian Thomaiyar                     << objectsWithConnection.size() << " requested "
2795f65af9e8SRichard Marian Thomaiyar                     << overrideMap.size() << "\n";
27964f277b54SJayaprakash Mutyala                 messages::resourceNotFound(sensorAsyncResp->asyncResp->res,
2797a0ec28b6SAdrian Ambrożewicz                                            sensorAsyncResp->chassisSubNode ==
2798a0ec28b6SAdrian Ambrożewicz                                                    sensors::node::thermal
2799413961deSRichard Marian Thomaiyar                                                ? "Temperatures"
2800413961deSRichard Marian Thomaiyar                                                : "Voltages",
2801f65af9e8SRichard Marian Thomaiyar                                            "Count");
2802f65af9e8SRichard Marian Thomaiyar                 return;
2803f65af9e8SRichard Marian Thomaiyar             }
2804f65af9e8SRichard Marian Thomaiyar             for (const auto& item : objectsWithConnection)
2805f65af9e8SRichard Marian Thomaiyar             {
280628aa8de5SGeorge Liu                 sdbusplus::message::object_path path(item.first);
280728aa8de5SGeorge Liu                 std::string sensorName = path.filename();
280828aa8de5SGeorge Liu                 if (sensorName.empty())
2809f65af9e8SRichard Marian Thomaiyar                 {
28104f277b54SJayaprakash Mutyala                     messages::internalError(sensorAsyncResp->asyncResp->res);
2811f65af9e8SRichard Marian Thomaiyar                     return;
2812f65af9e8SRichard Marian Thomaiyar                 }
2813f65af9e8SRichard Marian Thomaiyar 
2814f65af9e8SRichard Marian Thomaiyar                 const auto& iterator = overrideMap.find(sensorName);
2815f65af9e8SRichard Marian Thomaiyar                 if (iterator == overrideMap.end())
2816f65af9e8SRichard Marian Thomaiyar                 {
2817f65af9e8SRichard Marian Thomaiyar                     BMCWEB_LOG_INFO << "Unable to find sensor object"
2818f65af9e8SRichard Marian Thomaiyar                                     << item.first << "\n";
28194f277b54SJayaprakash Mutyala                     messages::internalError(sensorAsyncResp->asyncResp->res);
2820413961deSRichard Marian Thomaiyar                     return;
2821413961deSRichard Marian Thomaiyar                 }
2822413961deSRichard Marian Thomaiyar                 crow::connections::systemBus->async_method_call(
2823f65af9e8SRichard Marian Thomaiyar                     [sensorAsyncResp](const boost::system::error_code ec) {
2824413961deSRichard Marian Thomaiyar                     if (ec)
2825413961deSRichard Marian Thomaiyar                     {
28264f277b54SJayaprakash Mutyala                         if (ec.value() ==
28274f277b54SJayaprakash Mutyala                             boost::system::errc::permission_denied)
28284f277b54SJayaprakash Mutyala                         {
28294f277b54SJayaprakash Mutyala                             BMCWEB_LOG_WARNING
28304f277b54SJayaprakash Mutyala                                 << "Manufacturing mode is not Enabled...can't "
28314f277b54SJayaprakash Mutyala                                    "Override the sensor value. ";
28324f277b54SJayaprakash Mutyala 
28334f277b54SJayaprakash Mutyala                             messages::insufficientPrivilege(
28348d1b46d7Szhanghch05                                 sensorAsyncResp->asyncResp->res);
2835413961deSRichard Marian Thomaiyar                             return;
2836413961deSRichard Marian Thomaiyar                         }
28374f277b54SJayaprakash Mutyala                         BMCWEB_LOG_DEBUG
28384f277b54SJayaprakash Mutyala                             << "setOverrideValueStatus DBUS error: " << ec;
28394f277b54SJayaprakash Mutyala                         messages::internalError(
28404f277b54SJayaprakash Mutyala                             sensorAsyncResp->asyncResp->res);
28414f277b54SJayaprakash Mutyala                     }
2842413961deSRichard Marian Thomaiyar                     },
28434f277b54SJayaprakash Mutyala                     item.second, item.first, "org.freedesktop.DBus.Properties",
28444f277b54SJayaprakash Mutyala                     "Set", "xyz.openbmc_project.Sensor.Value", "Value",
2845168e20c1SEd Tanous                     dbus::utility::DbusVariantType(iterator->second.first));
2846f65af9e8SRichard Marian Thomaiyar             }
2847413961deSRichard Marian Thomaiyar         };
2848413961deSRichard Marian Thomaiyar         // Get object with connection for the given sensor name
2849413961deSRichard Marian Thomaiyar         getObjectsWithConnection(sensorAsyncResp, sensorNames,
2850413961deSRichard Marian Thomaiyar                                  std::move(getObjectsWithConnectionCb));
2851413961deSRichard Marian Thomaiyar     };
2852413961deSRichard Marian Thomaiyar     // get full sensor list for the given chassisId and cross verify the sensor.
28537f1cc26dSEd Tanous     getChassis(sensorAsyncResp->asyncResp, sensorAsyncResp->chassisId,
28547f1cc26dSEd Tanous                sensorAsyncResp->chassisSubNode, sensorAsyncResp->types,
28557f1cc26dSEd Tanous                std::move(getChassisSensorListCb));
2856413961deSRichard Marian Thomaiyar }
2857413961deSRichard Marian Thomaiyar 
2858a0ec28b6SAdrian Ambrożewicz /**
2859a0ec28b6SAdrian Ambrożewicz  * @brief Retrieves mapping of Redfish URIs to sensor value property to D-Bus
2860a0ec28b6SAdrian Ambrożewicz  * path of the sensor.
2861a0ec28b6SAdrian Ambrożewicz  *
2862a0ec28b6SAdrian Ambrożewicz  * Function builds valid Redfish response for sensor query of given chassis and
2863a0ec28b6SAdrian Ambrożewicz  * node. It then builds metadata about Redfish<->D-Bus correlations and provides
2864a0ec28b6SAdrian Ambrożewicz  * it to caller in a callback.
2865a0ec28b6SAdrian Ambrożewicz  *
2866a0ec28b6SAdrian Ambrożewicz  * @param chassis   Chassis for which retrieval should be performed
2867a0ec28b6SAdrian Ambrożewicz  * @param node  Node (group) of sensors. See sensors::node for supported values
2868a0ec28b6SAdrian Ambrożewicz  * @param mapComplete   Callback to be called with retrieval result
2869a0ec28b6SAdrian Ambrożewicz  */
2870021d32cfSKrzysztof Grobelny inline void retrieveUriToDbusMap(const std::string& chassis,
2871021d32cfSKrzysztof Grobelny                                  const std::string& node,
2872a0ec28b6SAdrian Ambrożewicz                                  SensorsAsyncResp::DataCompleteCb&& mapComplete)
2873a0ec28b6SAdrian Ambrożewicz {
287402da7c5aSEd Tanous     decltype(sensors::paths)::const_iterator pathIt =
287502da7c5aSEd Tanous         std::find_if(sensors::paths.cbegin(), sensors::paths.cend(),
287602da7c5aSEd Tanous                      [&node](auto&& val) { return val.first == node; });
287702da7c5aSEd Tanous     if (pathIt == sensors::paths.cend())
2878a0ec28b6SAdrian Ambrożewicz     {
2879a0ec28b6SAdrian Ambrożewicz         BMCWEB_LOG_ERROR << "Wrong node provided : " << node;
2880a0ec28b6SAdrian Ambrożewicz         mapComplete(boost::beast::http::status::bad_request, {});
2881a0ec28b6SAdrian Ambrożewicz         return;
2882a0ec28b6SAdrian Ambrożewicz     }
2883d51e072fSKrzysztof Grobelny 
288472374eb7SNan Zhou     auto asyncResp = std::make_shared<bmcweb::AsyncResp>();
2885fe04d49cSNan Zhou     auto callback = [asyncResp, mapCompleteCb{std::move(mapComplete)}](
2886a0ec28b6SAdrian Ambrożewicz                         const boost::beast::http::status status,
2887fe04d49cSNan Zhou                         const std::map<std::string, std::string>& uriToDbus) {
2888fe04d49cSNan Zhou         mapCompleteCb(status, uriToDbus);
2889fe04d49cSNan Zhou     };
2890a0ec28b6SAdrian Ambrożewicz 
2891a0ec28b6SAdrian Ambrożewicz     auto resp = std::make_shared<SensorsAsyncResp>(
2892d51e072fSKrzysztof Grobelny         asyncResp, chassis, pathIt->second, node, std::move(callback));
2893a0ec28b6SAdrian Ambrożewicz     getChassisData(resp);
2894a0ec28b6SAdrian Ambrożewicz }
2895a0ec28b6SAdrian Ambrożewicz 
2896bacb2162SNan Zhou namespace sensors
2897bacb2162SNan Zhou {
2898928fefb9SNan Zhou 
2899bacb2162SNan Zhou inline void getChassisCallback(
2900c1d019a6SEd Tanous     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2901c1d019a6SEd Tanous     std::string_view chassisId, std::string_view chassisSubNode,
2902fe04d49cSNan Zhou     const std::shared_ptr<std::set<std::string>>& sensorNames)
2903bacb2162SNan Zhou {
2904bacb2162SNan Zhou     BMCWEB_LOG_DEBUG << "getChassisCallback enter ";
2905bacb2162SNan Zhou 
2906c1d019a6SEd Tanous     nlohmann::json& entriesArray = asyncResp->res.jsonValue["Members"];
2907c1d019a6SEd Tanous     for (const std::string& sensor : *sensorNames)
2908bacb2162SNan Zhou     {
2909bacb2162SNan Zhou         BMCWEB_LOG_DEBUG << "Adding sensor: " << sensor;
2910bacb2162SNan Zhou 
2911bacb2162SNan Zhou         sdbusplus::message::object_path path(sensor);
2912bacb2162SNan Zhou         std::string sensorName = path.filename();
2913bacb2162SNan Zhou         if (sensorName.empty())
2914bacb2162SNan Zhou         {
2915bacb2162SNan Zhou             BMCWEB_LOG_ERROR << "Invalid sensor path: " << sensor;
2916c1d019a6SEd Tanous             messages::internalError(asyncResp->res);
2917bacb2162SNan Zhou             return;
2918bacb2162SNan Zhou         }
2919c1d019a6SEd Tanous         std::string type = path.parent_path().filename();
2920c1d019a6SEd Tanous         // fan_tach has an underscore in it, so remove it to "normalize" the
2921c1d019a6SEd Tanous         // type in the URI
2922c1d019a6SEd Tanous         type.erase(std::remove(type.begin(), type.end(), '_'), type.end());
2923c1d019a6SEd Tanous 
29241476687dSEd Tanous         nlohmann::json::object_t member;
2925c1d019a6SEd Tanous         std::string id = type;
2926c1d019a6SEd Tanous         id += "_";
2927c1d019a6SEd Tanous         id += sensorName;
2928c1d019a6SEd Tanous         member["@odata.id"] = crow::utility::urlFromPieces(
2929c1d019a6SEd Tanous             "redfish", "v1", "Chassis", chassisId, chassisSubNode, id);
2930c1d019a6SEd Tanous 
29311476687dSEd Tanous         entriesArray.push_back(std::move(member));
2932bacb2162SNan Zhou     }
2933bacb2162SNan Zhou 
2934c1d019a6SEd Tanous     asyncResp->res.jsonValue["Members@odata.count"] = entriesArray.size();
2935bacb2162SNan Zhou     BMCWEB_LOG_DEBUG << "getChassisCallback exit";
2936bacb2162SNan Zhou }
2937e6bd846dSNan Zhou 
2938de167a6fSNan Zhou inline void
2939de167a6fSNan Zhou     handleSensorCollectionGet(App& app, const crow::Request& req,
2940de167a6fSNan Zhou                               const std::shared_ptr<bmcweb::AsyncResp>& aResp,
2941de167a6fSNan Zhou                               const std::string& chassisId)
2942de167a6fSNan Zhou {
2943de167a6fSNan Zhou     query_param::QueryCapabilities capabilities = {
2944de167a6fSNan Zhou         .canDelegateExpandLevel = 1,
2945de167a6fSNan Zhou     };
2946de167a6fSNan Zhou     query_param::Query delegatedQuery;
29473ba00073SCarson Labrado     if (!redfish::setUpRedfishRouteWithDelegation(app, req, aResp,
2948de167a6fSNan Zhou                                                   delegatedQuery, capabilities))
2949de167a6fSNan Zhou     {
2950de167a6fSNan Zhou         return;
2951de167a6fSNan Zhou     }
2952de167a6fSNan Zhou 
2953de167a6fSNan Zhou     if (delegatedQuery.expandType != query_param::ExpandType::None)
2954de167a6fSNan Zhou     {
2955de167a6fSNan Zhou         // we perform efficient expand.
2956de167a6fSNan Zhou         auto asyncResp = std::make_shared<SensorsAsyncResp>(
2957de167a6fSNan Zhou             aResp, chassisId, sensors::dbus::sensorPaths,
2958de167a6fSNan Zhou             sensors::node::sensors,
2959de167a6fSNan Zhou             /*efficientExpand=*/true);
2960de167a6fSNan Zhou         getChassisData(asyncResp);
2961de167a6fSNan Zhou 
2962de167a6fSNan Zhou         BMCWEB_LOG_DEBUG
2963de167a6fSNan Zhou             << "SensorCollection doGet exit via efficient expand handler";
2964de167a6fSNan Zhou         return;
29650bad320cSEd Tanous     }
2966de167a6fSNan Zhou 
2967de167a6fSNan Zhou     // We get all sensors as hyperlinkes in the chassis (this
2968de167a6fSNan Zhou     // implies we reply on the default query parameters handler)
2969c1d019a6SEd Tanous     getChassis(aResp, chassisId, sensors::node::sensors, dbus::sensorPaths,
2970c1d019a6SEd Tanous                std::bind_front(sensors::getChassisCallback, aResp, chassisId,
2971c1d019a6SEd Tanous                                sensors::node::sensors));
2972c1d019a6SEd Tanous }
29737f1cc26dSEd Tanous 
2974c1d019a6SEd Tanous inline void
2975c1d019a6SEd Tanous     getSensorFromDbus(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2976c1d019a6SEd Tanous                       const std::string& sensorPath,
2977c1d019a6SEd Tanous                       const ::dbus::utility::MapperGetObject& mapperResponse)
2978c1d019a6SEd Tanous {
2979c1d019a6SEd Tanous     if (mapperResponse.size() != 1)
2980c1d019a6SEd Tanous     {
2981c1d019a6SEd Tanous         messages::internalError(asyncResp->res);
2982c1d019a6SEd Tanous         return;
2983c1d019a6SEd Tanous     }
2984c1d019a6SEd Tanous     const auto& valueIface = *mapperResponse.begin();
2985c1d019a6SEd Tanous     const std::string& connectionName = valueIface.first;
2986c1d019a6SEd Tanous     BMCWEB_LOG_DEBUG << "Looking up " << connectionName;
2987c1d019a6SEd Tanous     BMCWEB_LOG_DEBUG << "Path " << sensorPath;
2988*c1343bf6SKrzysztof Grobelny 
2989*c1343bf6SKrzysztof Grobelny     sdbusplus::asio::getAllProperties(
2990*c1343bf6SKrzysztof Grobelny         *crow::connections::systemBus, connectionName, sensorPath, "",
2991c1d019a6SEd Tanous         [asyncResp,
2992c1d019a6SEd Tanous          sensorPath](const boost::system::error_code ec,
2993c1d019a6SEd Tanous                      const ::dbus::utility::DBusPropertiesMap& valuesDict) {
2994c1d019a6SEd Tanous         if (ec)
2995c1d019a6SEd Tanous         {
2996c1d019a6SEd Tanous             messages::internalError(asyncResp->res);
2997c1d019a6SEd Tanous             return;
2998c1d019a6SEd Tanous         }
2999c1d019a6SEd Tanous         sdbusplus::message::object_path path(sensorPath);
3000c1d019a6SEd Tanous         std::string name = path.filename();
3001c1d019a6SEd Tanous         path = path.parent_path();
3002c1d019a6SEd Tanous         std::string type = path.filename();
3003c1d019a6SEd Tanous         objectPropertiesToJson(name, type, sensors::node::sensors, valuesDict,
3004c1d019a6SEd Tanous                                asyncResp->res.jsonValue, nullptr);
3005*c1343bf6SKrzysztof Grobelny         });
3006de167a6fSNan Zhou }
3007de167a6fSNan Zhou 
3008e6bd846dSNan Zhou inline void handleSensorGet(App& app, const crow::Request& req,
3009c1d019a6SEd Tanous                             const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3010c1d019a6SEd Tanous                             const std::string& /*chassisId*/,
3011c1d019a6SEd Tanous                             const std::string& sensorId)
3012e6bd846dSNan Zhou {
3013c1d019a6SEd Tanous     if (!redfish::setUpRedfishRoute(app, req, asyncResp))
3014e6bd846dSNan Zhou     {
3015e6bd846dSNan Zhou         return;
3016e6bd846dSNan Zhou     }
3017c1d019a6SEd Tanous     size_t index = sensorId.find('_');
3018c1d019a6SEd Tanous     if (index == std::string::npos)
3019c1d019a6SEd Tanous     {
3020c1d019a6SEd Tanous         messages::resourceNotFound(asyncResp->res, sensorId, "Sensor");
3021c1d019a6SEd Tanous         return;
3022c1d019a6SEd Tanous     }
3023c1d019a6SEd Tanous     std::string sensorType = sensorId.substr(0, index);
3024c1d019a6SEd Tanous     std::string sensorName = sensorId.substr(index + 1);
3025c1d019a6SEd Tanous     // fan_pwm and fan_tach need special handling
3026c1d019a6SEd Tanous     if (sensorType == "fantach" || sensorType == "fanpwm")
3027c1d019a6SEd Tanous     {
3028c1d019a6SEd Tanous         sensorType.insert(3, 1, '_');
3029c1d019a6SEd Tanous     }
3030c1d019a6SEd Tanous 
3031e6bd846dSNan Zhou     BMCWEB_LOG_DEBUG << "Sensor doGet enter";
3032e6bd846dSNan Zhou 
3033e6bd846dSNan Zhou     const std::array<const char*, 1> interfaces = {
3034e6bd846dSNan Zhou         "xyz.openbmc_project.Sensor.Value"};
3035c1d019a6SEd Tanous     std::string sensorPath =
3036c1d019a6SEd Tanous         "/xyz/openbmc_project/sensors/" + sensorType + '/' + sensorName;
3037e6bd846dSNan Zhou     // Get a list of all of the sensors that implement Sensor.Value
3038e6bd846dSNan Zhou     // and get the path and service name associated with the sensor
3039e6bd846dSNan Zhou     crow::connections::systemBus->async_method_call(
3040c1d019a6SEd Tanous         [asyncResp, sensorPath,
3041e6bd846dSNan Zhou          sensorName](const boost::system::error_code ec,
3042c1d019a6SEd Tanous                      const ::dbus::utility::MapperGetObject& subtree) {
3043e6bd846dSNan Zhou         BMCWEB_LOG_DEBUG << "respHandler1 enter";
3044e6bd846dSNan Zhou         if (ec)
3045e6bd846dSNan Zhou         {
3046c1d019a6SEd Tanous             messages::internalError(asyncResp->res);
3047e6bd846dSNan Zhou             BMCWEB_LOG_ERROR << "Sensor getSensorPaths resp_handler: "
3048e6bd846dSNan Zhou                              << "Dbus error " << ec;
3049e6bd846dSNan Zhou             return;
3050e6bd846dSNan Zhou         }
3051c1d019a6SEd Tanous         getSensorFromDbus(asyncResp, sensorPath, subtree);
3052e6bd846dSNan Zhou         BMCWEB_LOG_DEBUG << "respHandler1 exit";
3053e6bd846dSNan Zhou         },
3054e6bd846dSNan Zhou         "xyz.openbmc_project.ObjectMapper",
3055e6bd846dSNan Zhou         "/xyz/openbmc_project/object_mapper",
3056c1d019a6SEd Tanous         "xyz.openbmc_project.ObjectMapper", "GetObject", sensorPath,
3057c1d019a6SEd Tanous         interfaces);
3058e6bd846dSNan Zhou }
3059e6bd846dSNan Zhou 
3060bacb2162SNan Zhou } // namespace sensors
3061bacb2162SNan Zhou 
30627e860f15SJohn Edward Broadbent inline void requestRoutesSensorCollection(App& app)
306395a3ecadSAnthony Wilson {
30647e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Sensors/")
3065ed398213SEd Tanous         .privileges(redfish::privileges::getSensorCollection)
3066002d39b4SEd Tanous         .methods(boost::beast::http::verb::get)(
3067de167a6fSNan Zhou             std::bind_front(sensors::handleSensorCollectionGet, std::ref(app)));
306895a3ecadSAnthony Wilson }
306995a3ecadSAnthony Wilson 
30707e860f15SJohn Edward Broadbent inline void requestRoutesSensor(App& app)
307195a3ecadSAnthony Wilson {
30727e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Sensors/<str>/")
3073ed398213SEd Tanous         .privileges(redfish::privileges::getSensor)
3074002d39b4SEd Tanous         .methods(boost::beast::http::verb::get)(
3075e6bd846dSNan Zhou             std::bind_front(sensors::handleSensorGet, std::ref(app)));
307695a3ecadSAnthony Wilson }
307795a3ecadSAnthony Wilson 
307808777fb0SLewanczyk, Dawid } // namespace redfish
3079