xref: /openbmc/bmcweb/features/redfish/lib/sensors.hpp (revision 4f9a213046d031b50d162f2ffb41464ab432b144)
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 
1808777fb0SLewanczyk, Dawid #include <math.h>
191abe55efSEd Tanous 
2008777fb0SLewanczyk, Dawid #include <boost/algorithm/string/predicate.hpp>
2108777fb0SLewanczyk, Dawid #include <boost/algorithm/string/split.hpp>
2208777fb0SLewanczyk, Dawid #include <boost/container/flat_map.hpp>
2308777fb0SLewanczyk, Dawid #include <boost/range/algorithm/replace_copy_if.hpp>
241abe55efSEd Tanous #include <dbus_singleton.hpp>
25413961deSRichard Marian Thomaiyar #include <utils/json_utils.hpp>
26abf2add6SEd Tanous #include <variant>
2708777fb0SLewanczyk, Dawid 
281abe55efSEd Tanous namespace redfish
291abe55efSEd Tanous {
3008777fb0SLewanczyk, Dawid 
3108777fb0SLewanczyk, Dawid using GetSubTreeType = std::vector<
3208777fb0SLewanczyk, Dawid     std::pair<std::string,
3308777fb0SLewanczyk, Dawid               std::vector<std::pair<std::string, std::vector<std::string>>>>>;
3408777fb0SLewanczyk, Dawid 
35abf2add6SEd Tanous using SensorVariant = std::variant<int64_t, double>;
36aa2e59c1SEd Tanous 
3708777fb0SLewanczyk, Dawid using ManagedObjectsVectorType = std::vector<std::pair<
38aa2e59c1SEd Tanous     sdbusplus::message::object_path,
3908777fb0SLewanczyk, Dawid     boost::container::flat_map<
40aa2e59c1SEd Tanous         std::string, boost::container::flat_map<std::string, SensorVariant>>>>;
4108777fb0SLewanczyk, Dawid 
4208777fb0SLewanczyk, Dawid /**
43588c3f0dSKowalski, Kamil  * SensorsAsyncResp
4408777fb0SLewanczyk, Dawid  * Gathers data needed for response processing after async calls are done
4508777fb0SLewanczyk, Dawid  */
461abe55efSEd Tanous class SensorsAsyncResp
471abe55efSEd Tanous {
4808777fb0SLewanczyk, Dawid   public:
4955c7b7a2SEd Tanous     SensorsAsyncResp(crow::Response& response, const std::string& chassisId,
50b01bf299SEd Tanous                      const std::initializer_list<const char*> types,
512474adfaSEd Tanous                      const std::string& subNode) :
5243b761d0SEd Tanous         res(response),
5343b761d0SEd Tanous         chassisId(chassisId), types(types), chassisSubNode(subNode)
541abe55efSEd Tanous     {
5508777fb0SLewanczyk, Dawid     }
5608777fb0SLewanczyk, Dawid 
571abe55efSEd Tanous     ~SensorsAsyncResp()
581abe55efSEd Tanous     {
591abe55efSEd Tanous         if (res.result() == boost::beast::http::status::internal_server_error)
601abe55efSEd Tanous         {
611abe55efSEd Tanous             // Reset the json object to clear out any data that made it in
621abe55efSEd Tanous             // before the error happened todo(ed) handle error condition with
631abe55efSEd Tanous             // proper code
6455c7b7a2SEd Tanous             res.jsonValue = nlohmann::json::object();
6508777fb0SLewanczyk, Dawid         }
6608777fb0SLewanczyk, Dawid         res.end();
6708777fb0SLewanczyk, Dawid     }
68588c3f0dSKowalski, Kamil 
6955c7b7a2SEd Tanous     crow::Response& res;
70588c3f0dSKowalski, Kamil     std::string chassisId{};
7108777fb0SLewanczyk, Dawid     const std::vector<const char*> types;
722474adfaSEd Tanous     std::string chassisSubNode{};
7308777fb0SLewanczyk, Dawid };
7408777fb0SLewanczyk, Dawid 
7508777fb0SLewanczyk, Dawid /**
76413961deSRichard Marian Thomaiyar  * @brief Get objects with connection necessary for sensors
77588c3f0dSKowalski, Kamil  * @param SensorsAsyncResp Pointer to object holding response data
7808777fb0SLewanczyk, Dawid  * @param sensorNames Sensors retrieved from chassis
7908777fb0SLewanczyk, Dawid  * @param callback Callback for processing gathered connections
8008777fb0SLewanczyk, Dawid  */
8108777fb0SLewanczyk, Dawid template <typename Callback>
82413961deSRichard Marian Thomaiyar void getObjectsWithConnection(
83413961deSRichard Marian Thomaiyar     std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp,
8449c53ac9SJohnathan Mantey     const std::shared_ptr<boost::container::flat_set<std::string>> sensorNames,
851abe55efSEd Tanous     Callback&& callback)
861abe55efSEd Tanous {
87413961deSRichard Marian Thomaiyar     BMCWEB_LOG_DEBUG << "getObjectsWithConnection enter";
8803b5bae3SJames Feist     const std::string path = "/xyz/openbmc_project/sensors";
8908777fb0SLewanczyk, Dawid     const std::array<std::string, 1> interfaces = {
9008777fb0SLewanczyk, Dawid         "xyz.openbmc_project.Sensor.Value"};
9108777fb0SLewanczyk, Dawid 
9208777fb0SLewanczyk, Dawid     // Response handler for parsing objects subtree
931abe55efSEd Tanous     auto respHandler = [callback{std::move(callback)}, SensorsAsyncResp,
941abe55efSEd Tanous                         sensorNames](const boost::system::error_code ec,
951abe55efSEd Tanous                                      const GetSubTreeType& subtree) {
96413961deSRichard Marian Thomaiyar         BMCWEB_LOG_DEBUG << "getObjectsWithConnection resp_handler enter";
971abe55efSEd Tanous         if (ec)
981abe55efSEd Tanous         {
995f7d88c4SEd Tanous             messages::internalError(SensorsAsyncResp->res);
100413961deSRichard Marian Thomaiyar             BMCWEB_LOG_ERROR
101413961deSRichard Marian Thomaiyar                 << "getObjectsWithConnection resp_handler: Dbus error " << ec;
10208777fb0SLewanczyk, Dawid             return;
10308777fb0SLewanczyk, Dawid         }
10408777fb0SLewanczyk, Dawid 
10555c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "Found " << subtree.size() << " subtrees";
10608777fb0SLewanczyk, Dawid 
10708777fb0SLewanczyk, Dawid         // Make unique list of connections only for requested sensor types and
10808777fb0SLewanczyk, Dawid         // found in the chassis
10908777fb0SLewanczyk, Dawid         boost::container::flat_set<std::string> connections;
110413961deSRichard Marian Thomaiyar         std::set<std::pair<std::string, std::string>> objectsWithConnection;
1111abe55efSEd Tanous         // Intrinsic to avoid malloc.  Most systems will have < 8 sensor
1121abe55efSEd Tanous         // producers
11308777fb0SLewanczyk, Dawid         connections.reserve(8);
11408777fb0SLewanczyk, Dawid 
11549c53ac9SJohnathan Mantey         BMCWEB_LOG_DEBUG << "sensorNames list count: " << sensorNames->size();
11649c53ac9SJohnathan Mantey         for (const std::string& tsensor : *sensorNames)
1171abe55efSEd Tanous         {
11855c7b7a2SEd Tanous             BMCWEB_LOG_DEBUG << "Sensor to find: " << tsensor;
11908777fb0SLewanczyk, Dawid         }
12008777fb0SLewanczyk, Dawid 
12108777fb0SLewanczyk, Dawid         for (const std::pair<
12208777fb0SLewanczyk, Dawid                  std::string,
12308777fb0SLewanczyk, Dawid                  std::vector<std::pair<std::string, std::vector<std::string>>>>&
1241abe55efSEd Tanous                  object : subtree)
1251abe55efSEd Tanous         {
12649c53ac9SJohnathan Mantey             if (sensorNames->find(object.first) != sensorNames->end())
1271abe55efSEd Tanous             {
12849c53ac9SJohnathan Mantey                 for (const std::pair<std::string, std::vector<std::string>>&
1291abe55efSEd Tanous                          objData : object.second)
1301abe55efSEd Tanous                 {
13149c53ac9SJohnathan Mantey                     BMCWEB_LOG_DEBUG << "Adding connection: " << objData.first;
13208777fb0SLewanczyk, Dawid                     connections.insert(objData.first);
133de629b6eSShawn McCarney                     objectsWithConnection.insert(
134de629b6eSShawn McCarney                         std::make_pair(object.first, objData.first));
13508777fb0SLewanczyk, Dawid                 }
13608777fb0SLewanczyk, Dawid             }
13708777fb0SLewanczyk, Dawid         }
13855c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "Found " << connections.size() << " connections";
139413961deSRichard Marian Thomaiyar         callback(std::move(connections), std::move(objectsWithConnection));
140413961deSRichard Marian Thomaiyar         BMCWEB_LOG_DEBUG << "getObjectsWithConnection resp_handler exit";
14108777fb0SLewanczyk, Dawid     };
14208777fb0SLewanczyk, Dawid     // Make call to ObjectMapper to find all sensors objects
14355c7b7a2SEd Tanous     crow::connections::systemBus->async_method_call(
14455c7b7a2SEd Tanous         std::move(respHandler), "xyz.openbmc_project.ObjectMapper",
1451abe55efSEd Tanous         "/xyz/openbmc_project/object_mapper",
1461abe55efSEd Tanous         "xyz.openbmc_project.ObjectMapper", "GetSubTree", path, 2, interfaces);
147413961deSRichard Marian Thomaiyar     BMCWEB_LOG_DEBUG << "getObjectsWithConnection exit";
148413961deSRichard Marian Thomaiyar }
149413961deSRichard Marian Thomaiyar 
150413961deSRichard Marian Thomaiyar /**
151413961deSRichard Marian Thomaiyar  * @brief Create connections necessary for sensors
152413961deSRichard Marian Thomaiyar  * @param SensorsAsyncResp Pointer to object holding response data
153413961deSRichard Marian Thomaiyar  * @param sensorNames Sensors retrieved from chassis
154413961deSRichard Marian Thomaiyar  * @param callback Callback for processing gathered connections
155413961deSRichard Marian Thomaiyar  */
156413961deSRichard Marian Thomaiyar template <typename Callback>
15749c53ac9SJohnathan Mantey void getConnections(
15849c53ac9SJohnathan Mantey     std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp,
15949c53ac9SJohnathan Mantey     const std::shared_ptr<boost::container::flat_set<std::string>> sensorNames,
160413961deSRichard Marian Thomaiyar     Callback&& callback)
161413961deSRichard Marian Thomaiyar {
162413961deSRichard Marian Thomaiyar     auto objectsWithConnectionCb =
163413961deSRichard Marian Thomaiyar         [callback](const boost::container::flat_set<std::string>& connections,
164413961deSRichard Marian Thomaiyar                    const std::set<std::pair<std::string, std::string>>&
165413961deSRichard Marian Thomaiyar                        objectsWithConnection) {
166413961deSRichard Marian Thomaiyar             callback(std::move(connections));
167413961deSRichard Marian Thomaiyar         };
168413961deSRichard Marian Thomaiyar     getObjectsWithConnection(SensorsAsyncResp, sensorNames,
169413961deSRichard Marian Thomaiyar                              std::move(objectsWithConnectionCb));
17008777fb0SLewanczyk, Dawid }
17108777fb0SLewanczyk, Dawid 
17208777fb0SLewanczyk, Dawid /**
17349c53ac9SJohnathan Mantey  * @brief Shrinks the list of sensors for processing
17449c53ac9SJohnathan Mantey  * @param SensorsAysncResp  The class holding the Redfish response
17549c53ac9SJohnathan Mantey  * @param allSensors  A list of all the sensors associated to the
17649c53ac9SJohnathan Mantey  * chassis element (i.e. baseboard, front panel, etc...)
17749c53ac9SJohnathan Mantey  * @param activeSensors A list that is a reduction of the incoming
17849c53ac9SJohnathan Mantey  * allSensors list.  Eliminate Thermal sensors when a Power request is
17949c53ac9SJohnathan Mantey  * made, and eliminate Power sensors when a Thermal request is made.
18049c53ac9SJohnathan Mantey  */
18149c53ac9SJohnathan Mantey void reduceSensorList(
18249c53ac9SJohnathan Mantey     std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp,
18349c53ac9SJohnathan Mantey     const std::vector<std::string>* allSensors,
18449c53ac9SJohnathan Mantey     std::shared_ptr<boost::container::flat_set<std::string>> activeSensors)
18549c53ac9SJohnathan Mantey {
18649c53ac9SJohnathan Mantey     if (SensorsAsyncResp == nullptr)
18749c53ac9SJohnathan Mantey     {
18849c53ac9SJohnathan Mantey         return;
18949c53ac9SJohnathan Mantey     }
19049c53ac9SJohnathan Mantey     if ((allSensors == nullptr) || (activeSensors == nullptr))
19149c53ac9SJohnathan Mantey     {
19249c53ac9SJohnathan Mantey         messages::resourceNotFound(
19349c53ac9SJohnathan Mantey             SensorsAsyncResp->res, SensorsAsyncResp->chassisSubNode,
19449c53ac9SJohnathan Mantey             SensorsAsyncResp->chassisSubNode == "Thermal" ? "Temperatures"
19549c53ac9SJohnathan Mantey                                                           : "Voltages");
19649c53ac9SJohnathan Mantey 
19749c53ac9SJohnathan Mantey         return;
19849c53ac9SJohnathan Mantey     }
19949c53ac9SJohnathan Mantey     if (allSensors->empty())
20049c53ac9SJohnathan Mantey     {
20149c53ac9SJohnathan Mantey         // Nothing to do, the activeSensors object is also empty
20249c53ac9SJohnathan Mantey         return;
20349c53ac9SJohnathan Mantey     }
20449c53ac9SJohnathan Mantey 
20549c53ac9SJohnathan Mantey     for (const char* type : SensorsAsyncResp->types)
20649c53ac9SJohnathan Mantey     {
20749c53ac9SJohnathan Mantey         for (const std::string& sensor : *allSensors)
20849c53ac9SJohnathan Mantey         {
20949c53ac9SJohnathan Mantey             if (boost::starts_with(sensor, type))
21049c53ac9SJohnathan Mantey             {
21149c53ac9SJohnathan Mantey                 activeSensors->emplace(sensor);
21249c53ac9SJohnathan Mantey             }
21349c53ac9SJohnathan Mantey         }
21449c53ac9SJohnathan Mantey     }
21549c53ac9SJohnathan Mantey }
21649c53ac9SJohnathan Mantey 
21749c53ac9SJohnathan Mantey /**
21808777fb0SLewanczyk, Dawid  * @brief Retrieves requested chassis sensors and redundancy data from DBus .
219588c3f0dSKowalski, Kamil  * @param SensorsAsyncResp   Pointer to object holding response data
22008777fb0SLewanczyk, Dawid  * @param callback  Callback for next step in gathered sensor processing
22108777fb0SLewanczyk, Dawid  */
22208777fb0SLewanczyk, Dawid template <typename Callback>
22349c53ac9SJohnathan Mantey void getChassis(std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp,
2241abe55efSEd Tanous                 Callback&& callback)
2251abe55efSEd Tanous {
22655c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "getChassis enter";
22749c53ac9SJohnathan Mantey     const std::array<const char*, 3> interfaces = {
22849c53ac9SJohnathan Mantey         "xyz.openbmc_project.Inventory.Item.Board",
22949c53ac9SJohnathan Mantey         "xyz.openbmc_project.Inventory.Item.Chassis",
23049c53ac9SJohnathan Mantey         "xyz.openbmc_project.Inventory.Item.PowerSupply"};
23149c53ac9SJohnathan Mantey     auto respHandler = [callback{std::move(callback)}, sensorsAsyncResp](
23249c53ac9SJohnathan Mantey                            const boost::system::error_code ec,
23349c53ac9SJohnathan Mantey                            const std::vector<std::string>& chassisPaths) {
23455c7b7a2SEd Tanous         BMCWEB_LOG_DEBUG << "getChassis respHandler enter";
2351abe55efSEd Tanous         if (ec)
2361abe55efSEd Tanous         {
23755c7b7a2SEd Tanous             BMCWEB_LOG_ERROR << "getChassis respHandler DBUS error: " << ec;
23849c53ac9SJohnathan Mantey             messages::internalError(sensorsAsyncResp->res);
23908777fb0SLewanczyk, Dawid             return;
24008777fb0SLewanczyk, Dawid         }
24108777fb0SLewanczyk, Dawid 
24249c53ac9SJohnathan Mantey         const std::string* chassisPath = nullptr;
24349c53ac9SJohnathan Mantey         std::string chassisName;
24449c53ac9SJohnathan Mantey         for (const std::string& chassis : chassisPaths)
2451abe55efSEd Tanous         {
24649c53ac9SJohnathan Mantey             std::size_t lastPos = chassis.rfind("/");
24749c53ac9SJohnathan Mantey             if (lastPos == std::string::npos)
2481abe55efSEd Tanous             {
24949c53ac9SJohnathan Mantey                 BMCWEB_LOG_ERROR << "Failed to find '/' in " << chassis;
250daf36e2eSEd Tanous                 continue;
251daf36e2eSEd Tanous             }
25249c53ac9SJohnathan Mantey             chassisName = chassis.substr(lastPos + 1);
25349c53ac9SJohnathan Mantey             if (chassisName == sensorsAsyncResp->chassisId)
2541abe55efSEd Tanous             {
25549c53ac9SJohnathan Mantey                 chassisPath = &chassis;
25649c53ac9SJohnathan Mantey                 break;
257daf36e2eSEd Tanous             }
25849c53ac9SJohnathan Mantey         }
25949c53ac9SJohnathan Mantey         if (chassisPath == nullptr)
2601abe55efSEd Tanous         {
26149c53ac9SJohnathan Mantey             messages::resourceNotFound(sensorsAsyncResp->res, "Chassis",
26249c53ac9SJohnathan Mantey                                        sensorsAsyncResp->chassisId);
26349c53ac9SJohnathan Mantey             return;
2641abe55efSEd Tanous         }
26508777fb0SLewanczyk, Dawid 
26649c53ac9SJohnathan Mantey         const std::string& chassisSubNode = sensorsAsyncResp->chassisSubNode;
26749c53ac9SJohnathan Mantey         if (chassisSubNode == "Power")
26849c53ac9SJohnathan Mantey         {
26949c53ac9SJohnathan Mantey             sensorsAsyncResp->res.jsonValue["@odata.type"] =
27049c53ac9SJohnathan Mantey                 "#Power.v1_5_2.Power";
27149c53ac9SJohnathan Mantey         }
27249c53ac9SJohnathan Mantey         else if (chassisSubNode == "Thermal")
27349c53ac9SJohnathan Mantey         {
27449c53ac9SJohnathan Mantey             sensorsAsyncResp->res.jsonValue["@odata.type"] =
27549c53ac9SJohnathan Mantey                 "#Thermal.v1_4_0.Thermal";
276*4f9a2130SJennifer Lee             sensorsAsyncResp->res.jsonValue["Fans"] = nlohmann::json::array();
277*4f9a2130SJennifer Lee             sensorsAsyncResp->res.jsonValue["Temperatures"] =
278*4f9a2130SJennifer Lee                 nlohmann::json::array();
27949c53ac9SJohnathan Mantey         }
28049c53ac9SJohnathan Mantey         sensorsAsyncResp->res.jsonValue["@odata.id"] =
28149c53ac9SJohnathan Mantey             "/redfish/v1/Chassis/" + sensorsAsyncResp->chassisId + "/" +
28249c53ac9SJohnathan Mantey             chassisSubNode;
28349c53ac9SJohnathan Mantey 
28449c53ac9SJohnathan Mantey         sensorsAsyncResp->res.jsonValue["@odata.context"] =
28549c53ac9SJohnathan Mantey             "/redfish/v1/$metadata#" + chassisSubNode + "." + chassisSubNode;
28649c53ac9SJohnathan Mantey         sensorsAsyncResp->res.jsonValue["Id"] = chassisSubNode;
28749c53ac9SJohnathan Mantey         sensorsAsyncResp->res.jsonValue["Name"] = chassisSubNode;
28849c53ac9SJohnathan Mantey 
28949c53ac9SJohnathan Mantey         // Get the list of sensors for this Chassis element
29049c53ac9SJohnathan Mantey         std::string sensorPath = *chassisPath + "/sensors";
29155c7b7a2SEd Tanous         crow::connections::systemBus->async_method_call(
29249c53ac9SJohnathan Mantey             [sensorsAsyncResp, callback{std::move(callback)}](
29349c53ac9SJohnathan Mantey                 const boost::system::error_code ec,
29449c53ac9SJohnathan Mantey                 const std::variant<std::vector<std::string>>&
29549c53ac9SJohnathan Mantey                     variantEndpoints) {
29649c53ac9SJohnathan Mantey                 if (ec)
29749c53ac9SJohnathan Mantey                 {
29849c53ac9SJohnathan Mantey                     if (ec.value() != EBADR)
29949c53ac9SJohnathan Mantey                     {
30049c53ac9SJohnathan Mantey                         messages::internalError(sensorsAsyncResp->res);
30149c53ac9SJohnathan Mantey                         return;
30249c53ac9SJohnathan Mantey                     }
30349c53ac9SJohnathan Mantey                 }
30449c53ac9SJohnathan Mantey                 const std::vector<std::string>* nodeSensorList =
30549c53ac9SJohnathan Mantey                     std::get_if<std::vector<std::string>>(&(variantEndpoints));
30649c53ac9SJohnathan Mantey                 if (nodeSensorList == nullptr)
30749c53ac9SJohnathan Mantey                 {
30849c53ac9SJohnathan Mantey                     messages::resourceNotFound(
30949c53ac9SJohnathan Mantey                         sensorsAsyncResp->res, sensorsAsyncResp->chassisSubNode,
31049c53ac9SJohnathan Mantey                         sensorsAsyncResp->chassisSubNode == "Thermal"
31149c53ac9SJohnathan Mantey                             ? "Temperatures"
31249c53ac9SJohnathan Mantey                             : "Voltages");
31349c53ac9SJohnathan Mantey                     return;
31449c53ac9SJohnathan Mantey                 }
31549c53ac9SJohnathan Mantey                 const std::shared_ptr<boost::container::flat_set<std::string>>
31649c53ac9SJohnathan Mantey                     culledSensorList = std::make_shared<
31749c53ac9SJohnathan Mantey                         boost::container::flat_set<std::string>>();
31849c53ac9SJohnathan Mantey                 reduceSensorList(sensorsAsyncResp, nodeSensorList,
31949c53ac9SJohnathan Mantey                                  culledSensorList);
32049c53ac9SJohnathan Mantey                 callback(culledSensorList);
32149c53ac9SJohnathan Mantey             },
32249c53ac9SJohnathan Mantey             "xyz.openbmc_project.ObjectMapper", sensorPath,
32349c53ac9SJohnathan Mantey             "org.freedesktop.DBus.Properties", "Get",
32449c53ac9SJohnathan Mantey             "xyz.openbmc_project.Association", "endpoints");
32549c53ac9SJohnathan Mantey     };
32649c53ac9SJohnathan Mantey 
32749c53ac9SJohnathan Mantey     // Get the Chassis Collection
32849c53ac9SJohnathan Mantey     crow::connections::systemBus->async_method_call(
32949c53ac9SJohnathan Mantey         respHandler, "xyz.openbmc_project.ObjectMapper",
33049c53ac9SJohnathan Mantey         "/xyz/openbmc_project/object_mapper",
33149c53ac9SJohnathan Mantey         "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
33249c53ac9SJohnathan Mantey         "/xyz/openbmc_project/inventory", int32_t(0), interfaces);
33355c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "getChassis exit";
33408777fb0SLewanczyk, Dawid }
33508777fb0SLewanczyk, Dawid 
33608777fb0SLewanczyk, Dawid /**
337de629b6eSShawn McCarney  * @brief Finds all DBus object paths that implement ObjectManager.
338de629b6eSShawn McCarney  *
339de629b6eSShawn McCarney  * Creates a mapping from the associated connection name to the object path.
340de629b6eSShawn McCarney  *
341de629b6eSShawn McCarney  * Finds the object paths asynchronously.  Invokes callback when information has
342de629b6eSShawn McCarney  * been obtained.
343de629b6eSShawn McCarney  *
344de629b6eSShawn McCarney  * The callback must have the following signature:
345de629b6eSShawn McCarney  *   @code
346de629b6eSShawn McCarney  *   callback(const boost::container::flat_map<std::string,
347de629b6eSShawn McCarney  *            std::string>& objectMgrPaths)
348de629b6eSShawn McCarney  *   @endcode
349de629b6eSShawn McCarney  *
35049c53ac9SJohnathan Mantey  * @param sensorsAsyncResp Pointer to object holding response data.
351de629b6eSShawn McCarney  * @param callback Callback to invoke when object paths obtained.
352de629b6eSShawn McCarney  */
353de629b6eSShawn McCarney template <typename Callback>
354de629b6eSShawn McCarney void getObjectManagerPaths(std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp,
355de629b6eSShawn McCarney                            Callback&& callback)
356de629b6eSShawn McCarney {
357de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getObjectManagerPaths enter";
358de629b6eSShawn McCarney     const std::array<std::string, 1> interfaces = {
359de629b6eSShawn McCarney         "org.freedesktop.DBus.ObjectManager"};
360de629b6eSShawn McCarney 
361de629b6eSShawn McCarney     // Response handler for GetSubTree DBus method
362de629b6eSShawn McCarney     auto respHandler = [callback{std::move(callback)},
363de629b6eSShawn McCarney                         SensorsAsyncResp](const boost::system::error_code ec,
364de629b6eSShawn McCarney                                           const GetSubTreeType& subtree) {
365de629b6eSShawn McCarney         BMCWEB_LOG_DEBUG << "getObjectManagerPaths respHandler enter";
366de629b6eSShawn McCarney         if (ec)
367de629b6eSShawn McCarney         {
368de629b6eSShawn McCarney             messages::internalError(SensorsAsyncResp->res);
369de629b6eSShawn McCarney             BMCWEB_LOG_ERROR << "getObjectManagerPaths respHandler: DBus error "
370de629b6eSShawn McCarney                              << ec;
371de629b6eSShawn McCarney             return;
372de629b6eSShawn McCarney         }
373de629b6eSShawn McCarney 
374de629b6eSShawn McCarney         // Loop over returned object paths
375de629b6eSShawn McCarney         boost::container::flat_map<std::string, std::string> objectMgrPaths;
376de629b6eSShawn McCarney         for (const std::pair<
377de629b6eSShawn McCarney                  std::string,
378de629b6eSShawn McCarney                  std::vector<std::pair<std::string, std::vector<std::string>>>>&
379de629b6eSShawn McCarney                  object : subtree)
380de629b6eSShawn McCarney         {
381de629b6eSShawn McCarney             // Loop over connections for current object path
382de629b6eSShawn McCarney             const std::string& objectPath = object.first;
383de629b6eSShawn McCarney             for (const std::pair<std::string, std::vector<std::string>>&
384de629b6eSShawn McCarney                      objData : object.second)
385de629b6eSShawn McCarney             {
386de629b6eSShawn McCarney                 // Add mapping from connection to object path
387de629b6eSShawn McCarney                 const std::string& connection = objData.first;
388de629b6eSShawn McCarney                 objectMgrPaths[connection] = objectPath;
389de629b6eSShawn McCarney                 BMCWEB_LOG_DEBUG << "Added mapping " << connection << " -> "
390de629b6eSShawn McCarney                                  << objectPath;
391de629b6eSShawn McCarney             }
392de629b6eSShawn McCarney         }
393de629b6eSShawn McCarney         callback(std::move(objectMgrPaths));
394de629b6eSShawn McCarney         BMCWEB_LOG_DEBUG << "getObjectManagerPaths respHandler exit";
395de629b6eSShawn McCarney     };
396de629b6eSShawn McCarney 
397de629b6eSShawn McCarney     // Query mapper for all DBus object paths that implement ObjectManager
398de629b6eSShawn McCarney     crow::connections::systemBus->async_method_call(
399de629b6eSShawn McCarney         std::move(respHandler), "xyz.openbmc_project.ObjectMapper",
400de629b6eSShawn McCarney         "/xyz/openbmc_project/object_mapper",
401de629b6eSShawn McCarney         "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", int32_t(0),
402de629b6eSShawn McCarney         interfaces);
403de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getObjectManagerPaths exit";
404de629b6eSShawn McCarney }
405de629b6eSShawn McCarney 
406de629b6eSShawn McCarney /**
40708777fb0SLewanczyk, Dawid  * @brief Builds a json sensor representation of a sensor.
40808777fb0SLewanczyk, Dawid  * @param sensorName  The name of the sensor to be built
409274fad5aSGunnar Mills  * @param sensorType  The type (temperature, fan_tach, etc) of the sensor to
41008777fb0SLewanczyk, Dawid  * build
41108777fb0SLewanczyk, Dawid  * @param interfacesDict  A dictionary of the interfaces and properties of said
41208777fb0SLewanczyk, Dawid  * interfaces to be built from
41308777fb0SLewanczyk, Dawid  * @param sensor_json  The json object to fill
41408777fb0SLewanczyk, Dawid  */
41508777fb0SLewanczyk, Dawid void objectInterfacesToJson(
41608777fb0SLewanczyk, Dawid     const std::string& sensorName, const std::string& sensorType,
41708777fb0SLewanczyk, Dawid     const boost::container::flat_map<
418aa2e59c1SEd Tanous         std::string, boost::container::flat_map<std::string, SensorVariant>>&
41908777fb0SLewanczyk, Dawid         interfacesDict,
4201abe55efSEd Tanous     nlohmann::json& sensor_json)
4211abe55efSEd Tanous {
42208777fb0SLewanczyk, Dawid     // We need a value interface before we can do anything with it
42355c7b7a2SEd Tanous     auto valueIt = interfacesDict.find("xyz.openbmc_project.Sensor.Value");
4241abe55efSEd Tanous     if (valueIt == interfacesDict.end())
4251abe55efSEd Tanous     {
42655c7b7a2SEd Tanous         BMCWEB_LOG_ERROR << "Sensor doesn't have a value interface";
42708777fb0SLewanczyk, Dawid         return;
42808777fb0SLewanczyk, Dawid     }
42908777fb0SLewanczyk, Dawid 
43008777fb0SLewanczyk, Dawid     // Assume values exist as is (10^0 == 1) if no scale exists
43108777fb0SLewanczyk, Dawid     int64_t scaleMultiplier = 0;
43208777fb0SLewanczyk, Dawid 
43355c7b7a2SEd Tanous     auto scaleIt = valueIt->second.find("Scale");
43408777fb0SLewanczyk, Dawid     // If a scale exists, pull value as int64, and use the scaling.
4351abe55efSEd Tanous     if (scaleIt != valueIt->second.end())
4361abe55efSEd Tanous     {
437abf2add6SEd Tanous         const int64_t* int64Value = std::get_if<int64_t>(&scaleIt->second);
4381abe55efSEd Tanous         if (int64Value != nullptr)
4391abe55efSEd Tanous         {
44008777fb0SLewanczyk, Dawid             scaleMultiplier = *int64Value;
44108777fb0SLewanczyk, Dawid         }
44208777fb0SLewanczyk, Dawid     }
44308777fb0SLewanczyk, Dawid 
44408777fb0SLewanczyk, Dawid     sensor_json["MemberId"] = sensorName;
445e742b6ccSEd Tanous     sensor_json["Name"] = boost::replace_all_copy(sensorName, "_", " ");
446e742b6ccSEd Tanous 
44708777fb0SLewanczyk, Dawid     sensor_json["Status"]["State"] = "Enabled";
44808777fb0SLewanczyk, Dawid     sensor_json["Status"]["Health"] = "OK";
44908777fb0SLewanczyk, Dawid 
45008777fb0SLewanczyk, Dawid     // Parameter to set to override the type we get from dbus, and force it to
45108777fb0SLewanczyk, Dawid     // int, regardless of what is available.  This is used for schemas like fan,
45208777fb0SLewanczyk, Dawid     // that require integers, not floats.
45308777fb0SLewanczyk, Dawid     bool forceToInt = false;
45408777fb0SLewanczyk, Dawid 
45508777fb0SLewanczyk, Dawid     const char* unit = "Reading";
4561abe55efSEd Tanous     if (sensorType == "temperature")
4571abe55efSEd Tanous     {
45808777fb0SLewanczyk, Dawid         unit = "ReadingCelsius";
4597885954aSLewanczyk, Dawid         sensor_json["@odata.type"] = "#Thermal.v1_3_0.Temperature";
46008777fb0SLewanczyk, Dawid         // TODO(ed) Documentation says that path should be type fan_tach,
46108777fb0SLewanczyk, Dawid         // implementation seems to implement fan
4621abe55efSEd Tanous     }
4631abe55efSEd Tanous     else if (sensorType == "fan" || sensorType == "fan_tach")
4641abe55efSEd Tanous     {
46508777fb0SLewanczyk, Dawid         unit = "Reading";
46608777fb0SLewanczyk, Dawid         sensor_json["ReadingUnits"] = "RPM";
4677885954aSLewanczyk, Dawid         sensor_json["@odata.type"] = "#Thermal.v1_3_0.Fan";
46808777fb0SLewanczyk, Dawid         forceToInt = true;
4691abe55efSEd Tanous     }
4706f6d0d32SEd Tanous     else if (sensorType == "fan_pwm")
4716f6d0d32SEd Tanous     {
4726f6d0d32SEd Tanous         unit = "Reading";
4736f6d0d32SEd Tanous         sensor_json["ReadingUnits"] = "Percent";
4746f6d0d32SEd Tanous         sensor_json["@odata.type"] = "#Thermal.v1_3_0.Fan";
4756f6d0d32SEd Tanous         forceToInt = true;
4766f6d0d32SEd Tanous     }
4771abe55efSEd Tanous     else if (sensorType == "voltage")
4781abe55efSEd Tanous     {
47908777fb0SLewanczyk, Dawid         unit = "ReadingVolts";
4807885954aSLewanczyk, Dawid         sensor_json["@odata.type"] = "#Power.v1_0_0.Voltage";
4811abe55efSEd Tanous     }
4822474adfaSEd Tanous     else if (sensorType == "power")
4832474adfaSEd Tanous     {
48449c53ac9SJohnathan Mantey         std::string sensorNameLower =
48549c53ac9SJohnathan Mantey             boost::algorithm::to_lower_copy(sensorName);
48649c53ac9SJohnathan Mantey 
48749c53ac9SJohnathan Mantey         if (sensorNameLower.find("input") != std::string::npos)
48849c53ac9SJohnathan Mantey         {
48949c53ac9SJohnathan Mantey             unit = "PowerInputWatts";
49049c53ac9SJohnathan Mantey         }
49149c53ac9SJohnathan Mantey         else
49249c53ac9SJohnathan Mantey         {
49349c53ac9SJohnathan Mantey             unit = "PowerOutputWatts";
49449c53ac9SJohnathan Mantey         }
4952474adfaSEd Tanous     }
4961abe55efSEd Tanous     else
4971abe55efSEd Tanous     {
49855c7b7a2SEd Tanous         BMCWEB_LOG_ERROR << "Redfish cannot map object type for " << sensorName;
49908777fb0SLewanczyk, Dawid         return;
50008777fb0SLewanczyk, Dawid     }
50108777fb0SLewanczyk, Dawid     // Map of dbus interface name, dbus property name and redfish property_name
50208777fb0SLewanczyk, Dawid     std::vector<std::tuple<const char*, const char*, const char*>> properties;
50308777fb0SLewanczyk, Dawid     properties.reserve(7);
50408777fb0SLewanczyk, Dawid 
50508777fb0SLewanczyk, Dawid     properties.emplace_back("xyz.openbmc_project.Sensor.Value", "Value", unit);
506de629b6eSShawn McCarney 
507de629b6eSShawn McCarney     // If sensor type doesn't map to Redfish PowerSupply, add threshold props
508de629b6eSShawn McCarney     if ((sensorType != "current") && (sensorType != "power"))
509de629b6eSShawn McCarney     {
51008777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Warning",
51108777fb0SLewanczyk, Dawid                                 "WarningHigh", "UpperThresholdNonCritical");
51208777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Warning",
51308777fb0SLewanczyk, Dawid                                 "WarningLow", "LowerThresholdNonCritical");
51408777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Critical",
51508777fb0SLewanczyk, Dawid                                 "CriticalHigh", "UpperThresholdCritical");
51608777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Critical",
51708777fb0SLewanczyk, Dawid                                 "CriticalLow", "LowerThresholdCritical");
518de629b6eSShawn McCarney     }
51908777fb0SLewanczyk, Dawid 
5202474adfaSEd Tanous     // TODO Need to get UpperThresholdFatal and LowerThresholdFatal
5212474adfaSEd Tanous 
5221abe55efSEd Tanous     if (sensorType == "temperature")
5231abe55efSEd Tanous     {
52408777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MinValue",
52508777fb0SLewanczyk, Dawid                                 "MinReadingRangeTemp");
52608777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MaxValue",
52708777fb0SLewanczyk, Dawid                                 "MaxReadingRangeTemp");
5281abe55efSEd Tanous     }
529de629b6eSShawn McCarney     else if ((sensorType != "current") && (sensorType != "power"))
5301abe55efSEd Tanous     {
531de629b6eSShawn McCarney         // Sensor type doesn't map to Redfish PowerSupply; add min/max props
53208777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MinValue",
53308777fb0SLewanczyk, Dawid                                 "MinReadingRange");
53408777fb0SLewanczyk, Dawid         properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MaxValue",
53508777fb0SLewanczyk, Dawid                                 "MaxReadingRange");
53608777fb0SLewanczyk, Dawid     }
53708777fb0SLewanczyk, Dawid 
53808777fb0SLewanczyk, Dawid     for (const std::tuple<const char*, const char*, const char*>& p :
5391abe55efSEd Tanous          properties)
5401abe55efSEd Tanous     {
54108777fb0SLewanczyk, Dawid         auto interfaceProperties = interfacesDict.find(std::get<0>(p));
5421abe55efSEd Tanous         if (interfaceProperties != interfacesDict.end())
5431abe55efSEd Tanous         {
544b01bf299SEd Tanous             auto valueIt = interfaceProperties->second.find(std::get<1>(p));
545b01bf299SEd Tanous             if (valueIt != interfaceProperties->second.end())
5461abe55efSEd Tanous             {
547b01bf299SEd Tanous                 const SensorVariant& valueVariant = valueIt->second;
548b01bf299SEd Tanous                 nlohmann::json& valueIt = sensor_json[std::get<2>(p)];
54908777fb0SLewanczyk, Dawid                 // Attempt to pull the int64 directly
550abf2add6SEd Tanous                 const int64_t* int64Value = std::get_if<int64_t>(&valueVariant);
55108777fb0SLewanczyk, Dawid 
552abf2add6SEd Tanous                 const double* doubleValue = std::get_if<double>(&valueVariant);
5536f6d0d32SEd Tanous                 double temp = 0.0;
5546f6d0d32SEd Tanous                 if (int64Value != nullptr)
5551abe55efSEd Tanous                 {
5566f6d0d32SEd Tanous                     temp = *int64Value;
5576f6d0d32SEd Tanous                 }
5586f6d0d32SEd Tanous                 else if (doubleValue != nullptr)
5591abe55efSEd Tanous                 {
5606f6d0d32SEd Tanous                     temp = *doubleValue;
5611abe55efSEd Tanous                 }
5621abe55efSEd Tanous                 else
5631abe55efSEd Tanous                 {
5646f6d0d32SEd Tanous                     BMCWEB_LOG_ERROR
5656f6d0d32SEd Tanous                         << "Got value interface that wasn't int or double";
5666f6d0d32SEd Tanous                     continue;
56708777fb0SLewanczyk, Dawid                 }
5686f6d0d32SEd Tanous                 temp = temp * std::pow(10, scaleMultiplier);
5696f6d0d32SEd Tanous                 if (forceToInt)
5706f6d0d32SEd Tanous                 {
571b01bf299SEd Tanous                     valueIt = static_cast<int64_t>(temp);
5726f6d0d32SEd Tanous                 }
5736f6d0d32SEd Tanous                 else
5746f6d0d32SEd Tanous                 {
575b01bf299SEd Tanous                     valueIt = temp;
57608777fb0SLewanczyk, Dawid                 }
57708777fb0SLewanczyk, Dawid             }
57808777fb0SLewanczyk, Dawid         }
57908777fb0SLewanczyk, Dawid     }
58055c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "Added sensor " << sensorName;
58108777fb0SLewanczyk, Dawid }
58208777fb0SLewanczyk, Dawid 
5838bd25ccdSJames Feist static void
5848bd25ccdSJames Feist     populateFanRedundancy(std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp)
5858bd25ccdSJames Feist {
5868bd25ccdSJames Feist     crow::connections::systemBus->async_method_call(
5878bd25ccdSJames Feist         [sensorsAsyncResp](const boost::system::error_code ec,
5888bd25ccdSJames Feist                            const GetSubTreeType& resp) {
5898bd25ccdSJames Feist             if (ec)
5908bd25ccdSJames Feist             {
5918bd25ccdSJames Feist                 return; // don't have to have this interface
5928bd25ccdSJames Feist             }
593e278c18fSEd Tanous             for (const std::pair<std::string,
594e278c18fSEd Tanous                                  std::vector<std::pair<
595e278c18fSEd Tanous                                      std::string, std::vector<std::string>>>>&
596e278c18fSEd Tanous                      pathPair : resp)
5978bd25ccdSJames Feist             {
598e278c18fSEd Tanous                 const std::string& path = pathPair.first;
599e278c18fSEd Tanous                 const std::vector<
600e278c18fSEd Tanous                     std::pair<std::string, std::vector<std::string>>>& objDict =
601e278c18fSEd Tanous                     pathPair.second;
6028bd25ccdSJames Feist                 if (objDict.empty())
6038bd25ccdSJames Feist                 {
6048bd25ccdSJames Feist                     continue; // this should be impossible
6058bd25ccdSJames Feist                 }
6068bd25ccdSJames Feist 
6078bd25ccdSJames Feist                 const std::string& owner = objDict.begin()->first;
6088bd25ccdSJames Feist                 crow::connections::systemBus->async_method_call(
6098bd25ccdSJames Feist                     [path, owner,
6108bd25ccdSJames Feist                      sensorsAsyncResp](const boost::system::error_code ec,
6118bd25ccdSJames Feist                                        std::variant<std::vector<std::string>>
6128bd25ccdSJames Feist                                            variantEndpoints) {
6138bd25ccdSJames Feist                         if (ec)
6148bd25ccdSJames Feist                         {
6158bd25ccdSJames Feist                             return; // if they don't have an association we
6168bd25ccdSJames Feist                                     // can't tell what chassis is
6178bd25ccdSJames Feist                         }
6188bd25ccdSJames Feist                         // verify part of the right chassis
6198bd25ccdSJames Feist                         auto endpoints = std::get_if<std::vector<std::string>>(
6208bd25ccdSJames Feist                             &variantEndpoints);
6218bd25ccdSJames Feist 
6228bd25ccdSJames Feist                         if (endpoints == nullptr)
6238bd25ccdSJames Feist                         {
6248bd25ccdSJames Feist                             BMCWEB_LOG_ERROR << "Invalid association interface";
6258bd25ccdSJames Feist                             messages::internalError(sensorsAsyncResp->res);
6268bd25ccdSJames Feist                             return;
6278bd25ccdSJames Feist                         }
6288bd25ccdSJames Feist 
6298bd25ccdSJames Feist                         auto found = std::find_if(
6308bd25ccdSJames Feist                             endpoints->begin(), endpoints->end(),
6318bd25ccdSJames Feist                             [sensorsAsyncResp](const std::string& entry) {
6328bd25ccdSJames Feist                                 return entry.find(
6338bd25ccdSJames Feist                                            sensorsAsyncResp->chassisId) !=
6348bd25ccdSJames Feist                                        std::string::npos;
6358bd25ccdSJames Feist                             });
6368bd25ccdSJames Feist 
6378bd25ccdSJames Feist                         if (found == endpoints->end())
6388bd25ccdSJames Feist                         {
6398bd25ccdSJames Feist                             return;
6408bd25ccdSJames Feist                         }
6418bd25ccdSJames Feist                         crow::connections::systemBus->async_method_call(
6428bd25ccdSJames Feist                             [path, sensorsAsyncResp](
6438bd25ccdSJames Feist                                 const boost::system::error_code ec,
6448bd25ccdSJames Feist                                 const boost::container::flat_map<
6458bd25ccdSJames Feist                                     std::string,
6468bd25ccdSJames Feist                                     std::variant<uint8_t,
6478bd25ccdSJames Feist                                                  std::vector<std::string>,
6488bd25ccdSJames Feist                                                  std::string>>& ret) {
6498bd25ccdSJames Feist                                 if (ec)
6508bd25ccdSJames Feist                                 {
6518bd25ccdSJames Feist                                     return; // don't have to have this
6528bd25ccdSJames Feist                                             // interface
6538bd25ccdSJames Feist                                 }
6548bd25ccdSJames Feist                                 auto findFailures = ret.find("AllowedFailures");
6558bd25ccdSJames Feist                                 auto findCollection = ret.find("Collection");
6568bd25ccdSJames Feist                                 auto findStatus = ret.find("Status");
6578bd25ccdSJames Feist 
6588bd25ccdSJames Feist                                 if (findFailures == ret.end() ||
6598bd25ccdSJames Feist                                     findCollection == ret.end() ||
6608bd25ccdSJames Feist                                     findStatus == ret.end())
6618bd25ccdSJames Feist                                 {
6628bd25ccdSJames Feist                                     BMCWEB_LOG_ERROR
6638bd25ccdSJames Feist                                         << "Invalid redundancy interface";
6648bd25ccdSJames Feist                                     messages::internalError(
6658bd25ccdSJames Feist                                         sensorsAsyncResp->res);
6668bd25ccdSJames Feist                                     return;
6678bd25ccdSJames Feist                                 }
6688bd25ccdSJames Feist 
6698bd25ccdSJames Feist                                 auto allowedFailures = std::get_if<uint8_t>(
6708bd25ccdSJames Feist                                     &(findFailures->second));
6718bd25ccdSJames Feist                                 auto collection =
6728bd25ccdSJames Feist                                     std::get_if<std::vector<std::string>>(
6738bd25ccdSJames Feist                                         &(findCollection->second));
6748bd25ccdSJames Feist                                 auto status = std::get_if<std::string>(
6758bd25ccdSJames Feist                                     &(findStatus->second));
6768bd25ccdSJames Feist 
6778bd25ccdSJames Feist                                 if (allowedFailures == nullptr ||
6788bd25ccdSJames Feist                                     collection == nullptr || status == nullptr)
6798bd25ccdSJames Feist                                 {
6808bd25ccdSJames Feist 
6818bd25ccdSJames Feist                                     BMCWEB_LOG_ERROR
6828bd25ccdSJames Feist                                         << "Invalid redundancy interface "
6838bd25ccdSJames Feist                                            "types";
6848bd25ccdSJames Feist                                     messages::internalError(
6858bd25ccdSJames Feist                                         sensorsAsyncResp->res);
6868bd25ccdSJames Feist                                     return;
6878bd25ccdSJames Feist                                 }
6888bd25ccdSJames Feist                                 size_t lastSlash = path.rfind("/");
6898bd25ccdSJames Feist                                 if (lastSlash == std::string::npos)
6908bd25ccdSJames Feist                                 {
6918bd25ccdSJames Feist                                     // this should be impossible
6928bd25ccdSJames Feist                                     messages::internalError(
6938bd25ccdSJames Feist                                         sensorsAsyncResp->res);
6948bd25ccdSJames Feist                                     return;
6958bd25ccdSJames Feist                                 }
6968bd25ccdSJames Feist                                 std::string name = path.substr(lastSlash + 1);
6978bd25ccdSJames Feist                                 std::replace(name.begin(), name.end(), '_',
6988bd25ccdSJames Feist                                              ' ');
6998bd25ccdSJames Feist 
7008bd25ccdSJames Feist                                 std::string health;
7018bd25ccdSJames Feist 
7028bd25ccdSJames Feist                                 if (boost::ends_with(*status, "Full"))
7038bd25ccdSJames Feist                                 {
7048bd25ccdSJames Feist                                     health = "OK";
7058bd25ccdSJames Feist                                 }
7068bd25ccdSJames Feist                                 else if (boost::ends_with(*status, "Degraded"))
7078bd25ccdSJames Feist                                 {
7088bd25ccdSJames Feist                                     health = "Warning";
7098bd25ccdSJames Feist                                 }
7108bd25ccdSJames Feist                                 else
7118bd25ccdSJames Feist                                 {
7128bd25ccdSJames Feist                                     health = "Critical";
7138bd25ccdSJames Feist                                 }
7148bd25ccdSJames Feist                                 std::vector<nlohmann::json> redfishCollection;
7158bd25ccdSJames Feist                                 const auto& fanRedfish =
7168bd25ccdSJames Feist                                     sensorsAsyncResp->res.jsonValue["Fans"];
7178bd25ccdSJames Feist                                 for (const std::string& item : *collection)
7188bd25ccdSJames Feist                                 {
7198bd25ccdSJames Feist                                     lastSlash = item.rfind("/");
7208bd25ccdSJames Feist                                     // make a copy as collection is const
7218bd25ccdSJames Feist                                     std::string itemName =
7228bd25ccdSJames Feist                                         item.substr(lastSlash + 1);
7238bd25ccdSJames Feist                                     /*
7248bd25ccdSJames Feist                                     todo(ed): merge patch that fixes the names
7258bd25ccdSJames Feist                                     std::replace(itemName.begin(),
7268bd25ccdSJames Feist                                                  itemName.end(), '_', ' ');*/
7278bd25ccdSJames Feist                                     auto schemaItem = std::find_if(
7288bd25ccdSJames Feist                                         fanRedfish.begin(), fanRedfish.end(),
7298bd25ccdSJames Feist                                         [itemName](const nlohmann::json& fan) {
7308bd25ccdSJames Feist                                             return fan["MemberId"] == itemName;
7318bd25ccdSJames Feist                                         });
7328bd25ccdSJames Feist                                     if (schemaItem != fanRedfish.end())
7338bd25ccdSJames Feist                                     {
7348bd25ccdSJames Feist                                         redfishCollection.push_back(
7358bd25ccdSJames Feist                                             {{"@odata.id",
7368bd25ccdSJames Feist                                               (*schemaItem)["@odata.id"]}});
7378bd25ccdSJames Feist                                     }
7388bd25ccdSJames Feist                                     else
7398bd25ccdSJames Feist                                     {
7408bd25ccdSJames Feist                                         BMCWEB_LOG_ERROR
7418bd25ccdSJames Feist                                             << "failed to find fan in schema";
7428bd25ccdSJames Feist                                         messages::internalError(
7438bd25ccdSJames Feist                                             sensorsAsyncResp->res);
7448bd25ccdSJames Feist                                         return;
7458bd25ccdSJames Feist                                     }
7468bd25ccdSJames Feist                                 }
7478bd25ccdSJames Feist 
7488bd25ccdSJames Feist                                 auto& resp = sensorsAsyncResp->res
7498bd25ccdSJames Feist                                                  .jsonValue["Redundancy"];
7508bd25ccdSJames Feist                                 resp.push_back(
7518bd25ccdSJames Feist                                     {{"@odata.id",
7528bd25ccdSJames Feist                                       "/refish/v1/Chassis/" +
7538bd25ccdSJames Feist                                           sensorsAsyncResp->chassisId + "/" +
7548bd25ccdSJames Feist                                           sensorsAsyncResp->chassisSubNode +
7558bd25ccdSJames Feist                                           "#/Redundancy/" +
7568bd25ccdSJames Feist                                           std::to_string(resp.size())},
7578bd25ccdSJames Feist                                      {"@odata.type",
7588bd25ccdSJames Feist                                       "#Redundancy.v1_3_2.Redundancy"},
7598bd25ccdSJames Feist                                      {"MinNumNeeded",
7608bd25ccdSJames Feist                                       collection->size() - *allowedFailures},
7618bd25ccdSJames Feist                                      {"MemberId", name},
7628bd25ccdSJames Feist                                      {"Mode", "N+m"},
7638bd25ccdSJames Feist                                      {"Name", name},
7648bd25ccdSJames Feist                                      {"RedundancySet", redfishCollection},
7658bd25ccdSJames Feist                                      {"Status",
7668bd25ccdSJames Feist                                       {{"Health", health},
7678bd25ccdSJames Feist                                        {"State", "Enabled"}}}});
7688bd25ccdSJames Feist                             },
7698bd25ccdSJames Feist                             owner, path, "org.freedesktop.DBus.Properties",
7708bd25ccdSJames Feist                             "GetAll",
7718bd25ccdSJames Feist                             "xyz.openbmc_project.Control.FanRedundancy");
7728bd25ccdSJames Feist                     },
7738bd25ccdSJames Feist                     "xyz.openbmc_project.ObjectMapper", path + "/inventory",
7748bd25ccdSJames Feist                     "org.freedesktop.DBus.Properties", "Get",
7758bd25ccdSJames Feist                     "xyz.openbmc_project.Association", "endpoints");
7768bd25ccdSJames Feist             }
7778bd25ccdSJames Feist         },
7788bd25ccdSJames Feist         "xyz.openbmc_project.ObjectMapper",
7798bd25ccdSJames Feist         "/xyz/openbmc_project/object_mapper",
7808bd25ccdSJames Feist         "xyz.openbmc_project.ObjectMapper", "GetSubTree",
7818bd25ccdSJames Feist         "/xyz/openbmc_project/control", 2,
7828bd25ccdSJames Feist         std::array<const char*, 1>{
7838bd25ccdSJames Feist             "xyz.openbmc_project.Control.FanRedundancy"});
7848bd25ccdSJames Feist }
7858bd25ccdSJames Feist 
78649c53ac9SJohnathan Mantey void sortJSONResponse(std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp)
78749c53ac9SJohnathan Mantey {
78849c53ac9SJohnathan Mantey     nlohmann::json& response = SensorsAsyncResp->res.jsonValue;
78949c53ac9SJohnathan Mantey     std::array<std::string, 2> sensorHeaders{"Temperatures", "Fans"};
79049c53ac9SJohnathan Mantey     if (SensorsAsyncResp->chassisSubNode == "Power")
79149c53ac9SJohnathan Mantey     {
79249c53ac9SJohnathan Mantey         sensorHeaders = {"Voltages", "PowerSupplies"};
79349c53ac9SJohnathan Mantey     }
79449c53ac9SJohnathan Mantey     for (const std::string& sensorGroup : sensorHeaders)
79549c53ac9SJohnathan Mantey     {
79649c53ac9SJohnathan Mantey         nlohmann::json::iterator entry = response.find(sensorGroup);
79749c53ac9SJohnathan Mantey         if (entry != response.end())
79849c53ac9SJohnathan Mantey         {
79949c53ac9SJohnathan Mantey             std::sort(entry->begin(), entry->end(),
80049c53ac9SJohnathan Mantey                       [](nlohmann::json& c1, nlohmann::json& c2) {
80149c53ac9SJohnathan Mantey                           return c1["Name"] < c2["Name"];
80249c53ac9SJohnathan Mantey                       });
80349c53ac9SJohnathan Mantey 
80449c53ac9SJohnathan Mantey             // add the index counts to the end of each entry
80549c53ac9SJohnathan Mantey             size_t count = 0;
80649c53ac9SJohnathan Mantey             for (nlohmann::json& sensorJson : *entry)
80749c53ac9SJohnathan Mantey             {
80849c53ac9SJohnathan Mantey                 nlohmann::json::iterator odata = sensorJson.find("@odata.id");
80949c53ac9SJohnathan Mantey                 if (odata == sensorJson.end())
81049c53ac9SJohnathan Mantey                 {
81149c53ac9SJohnathan Mantey                     continue;
81249c53ac9SJohnathan Mantey                 }
81349c53ac9SJohnathan Mantey                 std::string* value = odata->get_ptr<std::string*>();
81449c53ac9SJohnathan Mantey                 if (value != nullptr)
81549c53ac9SJohnathan Mantey                 {
81649c53ac9SJohnathan Mantey                     *value += std::to_string(count);
81749c53ac9SJohnathan Mantey                     count++;
81849c53ac9SJohnathan Mantey                 }
81949c53ac9SJohnathan Mantey             }
82049c53ac9SJohnathan Mantey         }
82149c53ac9SJohnathan Mantey     }
82249c53ac9SJohnathan Mantey }
82349c53ac9SJohnathan Mantey 
82408777fb0SLewanczyk, Dawid /**
825de629b6eSShawn McCarney  * @brief Gets the values of the specified sensors.
826de629b6eSShawn McCarney  *
827de629b6eSShawn McCarney  * Stores the results as JSON in the SensorsAsyncResp.
828de629b6eSShawn McCarney  *
829de629b6eSShawn McCarney  * Gets the sensor values asynchronously.  Stores the results later when the
830de629b6eSShawn McCarney  * information has been obtained.
831de629b6eSShawn McCarney  *
832de629b6eSShawn McCarney  * The sensorNames set contains all sensors for the current chassis.
833de629b6eSShawn McCarney  * SensorsAsyncResp contains the requested sensor types.  Only sensors of a
834de629b6eSShawn McCarney  * requested type are included in the JSON output.
835de629b6eSShawn McCarney  *
836de629b6eSShawn McCarney  * To minimize the number of DBus calls, the DBus method
837de629b6eSShawn McCarney  * org.freedesktop.DBus.ObjectManager.GetManagedObjects() is used to get the
838de629b6eSShawn McCarney  * values of all sensors provided by a connection (service).
839de629b6eSShawn McCarney  *
840de629b6eSShawn McCarney  * The connections set contains all the connections that provide sensor values.
841de629b6eSShawn McCarney  *
842de629b6eSShawn McCarney  * The objectMgrPaths map contains mappings from a connection name to the
843de629b6eSShawn McCarney  * corresponding DBus object path that implements ObjectManager.
844de629b6eSShawn McCarney  *
845de629b6eSShawn McCarney  * @param SensorsAsyncResp Pointer to object holding response data.
846de629b6eSShawn McCarney  * @param sensorNames All sensors within the current chassis.
847de629b6eSShawn McCarney  * @param connections Connections that provide sensor values.
848de629b6eSShawn McCarney  * @param objectMgrPaths Mappings from connection name to DBus object path that
849de629b6eSShawn McCarney  * implements ObjectManager.
850de629b6eSShawn McCarney  */
851de629b6eSShawn McCarney void getSensorData(
852de629b6eSShawn McCarney     std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp,
85349c53ac9SJohnathan Mantey     const std::shared_ptr<boost::container::flat_set<std::string>> sensorNames,
854de629b6eSShawn McCarney     const boost::container::flat_set<std::string>& connections,
855de629b6eSShawn McCarney     const boost::container::flat_map<std::string, std::string>& objectMgrPaths)
856de629b6eSShawn McCarney {
857de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getSensorData enter";
858de629b6eSShawn McCarney     // Get managed objects from all services exposing sensors
859de629b6eSShawn McCarney     for (const std::string& connection : connections)
860de629b6eSShawn McCarney     {
861de629b6eSShawn McCarney         // Response handler to process managed objects
86249c53ac9SJohnathan Mantey         auto getManagedObjectsCb = [SensorsAsyncResp, sensorNames](
863de629b6eSShawn McCarney                                        const boost::system::error_code ec,
864de629b6eSShawn McCarney                                        ManagedObjectsVectorType& resp) {
865de629b6eSShawn McCarney             BMCWEB_LOG_DEBUG << "getManagedObjectsCb enter";
866de629b6eSShawn McCarney             if (ec)
867de629b6eSShawn McCarney             {
868de629b6eSShawn McCarney                 BMCWEB_LOG_ERROR << "getManagedObjectsCb DBUS error: " << ec;
869de629b6eSShawn McCarney                 messages::internalError(SensorsAsyncResp->res);
870de629b6eSShawn McCarney                 return;
871de629b6eSShawn McCarney             }
872de629b6eSShawn McCarney             // Go through all objects and update response with sensor data
873de629b6eSShawn McCarney             for (const auto& objDictEntry : resp)
874de629b6eSShawn McCarney             {
875de629b6eSShawn McCarney                 const std::string& objPath =
876de629b6eSShawn McCarney                     static_cast<const std::string&>(objDictEntry.first);
877de629b6eSShawn McCarney                 BMCWEB_LOG_DEBUG << "getManagedObjectsCb parsing object "
878de629b6eSShawn McCarney                                  << objPath;
879de629b6eSShawn McCarney 
880de629b6eSShawn McCarney                 std::vector<std::string> split;
881de629b6eSShawn McCarney                 // Reserve space for
882de629b6eSShawn McCarney                 // /xyz/openbmc_project/sensors/<name>/<subname>
883de629b6eSShawn McCarney                 split.reserve(6);
884de629b6eSShawn McCarney                 boost::algorithm::split(split, objPath, boost::is_any_of("/"));
885de629b6eSShawn McCarney                 if (split.size() < 6)
886de629b6eSShawn McCarney                 {
887de629b6eSShawn McCarney                     BMCWEB_LOG_ERROR << "Got path that isn't long enough "
888de629b6eSShawn McCarney                                      << objPath;
889de629b6eSShawn McCarney                     continue;
890de629b6eSShawn McCarney                 }
891de629b6eSShawn McCarney                 // These indexes aren't intuitive, as boost::split puts an empty
892de629b6eSShawn McCarney                 // string at the beginning
893de629b6eSShawn McCarney                 const std::string& sensorType = split[4];
894de629b6eSShawn McCarney                 const std::string& sensorName = split[5];
895de629b6eSShawn McCarney                 BMCWEB_LOG_DEBUG << "sensorName " << sensorName
896de629b6eSShawn McCarney                                  << " sensorType " << sensorType;
89749c53ac9SJohnathan Mantey                 if (sensorNames->find(objPath) == sensorNames->end())
898de629b6eSShawn McCarney                 {
899de629b6eSShawn McCarney                     BMCWEB_LOG_ERROR << sensorName << " not in sensor list ";
900de629b6eSShawn McCarney                     continue;
901de629b6eSShawn McCarney                 }
902de629b6eSShawn McCarney 
903de629b6eSShawn McCarney                 const char* fieldName = nullptr;
904de629b6eSShawn McCarney                 if (sensorType == "temperature")
905de629b6eSShawn McCarney                 {
906de629b6eSShawn McCarney                     fieldName = "Temperatures";
907de629b6eSShawn McCarney                 }
908de629b6eSShawn McCarney                 else if (sensorType == "fan" || sensorType == "fan_tach" ||
909de629b6eSShawn McCarney                          sensorType == "fan_pwm")
910de629b6eSShawn McCarney                 {
911de629b6eSShawn McCarney                     fieldName = "Fans";
912de629b6eSShawn McCarney                 }
913de629b6eSShawn McCarney                 else if (sensorType == "voltage")
914de629b6eSShawn McCarney                 {
915de629b6eSShawn McCarney                     fieldName = "Voltages";
916de629b6eSShawn McCarney                 }
917de629b6eSShawn McCarney                 else if (sensorType == "current")
918de629b6eSShawn McCarney                 {
919de629b6eSShawn McCarney                     fieldName = "PowerSupplies";
920de629b6eSShawn McCarney                 }
921de629b6eSShawn McCarney                 else if (sensorType == "power")
922de629b6eSShawn McCarney                 {
923de629b6eSShawn McCarney                     fieldName = "PowerSupplies";
924de629b6eSShawn McCarney                 }
925de629b6eSShawn McCarney                 else
926de629b6eSShawn McCarney                 {
927de629b6eSShawn McCarney                     BMCWEB_LOG_ERROR << "Unsure how to handle sensorType "
928de629b6eSShawn McCarney                                      << sensorType;
929de629b6eSShawn McCarney                     continue;
930de629b6eSShawn McCarney                 }
931de629b6eSShawn McCarney 
932de629b6eSShawn McCarney                 nlohmann::json& tempArray =
933de629b6eSShawn McCarney                     SensorsAsyncResp->res.jsonValue[fieldName];
934de629b6eSShawn McCarney 
93549c53ac9SJohnathan Mantey                 if (fieldName == "PowerSupplies" && !tempArray.empty())
93649c53ac9SJohnathan Mantey                 {
93749c53ac9SJohnathan Mantey                     // Power supplies put multiple "sensors" into a single power
93849c53ac9SJohnathan Mantey                     // supply entry, so only create the first one
93949c53ac9SJohnathan Mantey                 }
94049c53ac9SJohnathan Mantey                 else
94149c53ac9SJohnathan Mantey                 {
942de629b6eSShawn McCarney                     tempArray.push_back(
94349c53ac9SJohnathan Mantey                         {{"@odata.id", "/redfish/v1/Chassis/" +
94449c53ac9SJohnathan Mantey                                            SensorsAsyncResp->chassisId + "/" +
94549c53ac9SJohnathan Mantey                                            SensorsAsyncResp->chassisSubNode +
94649c53ac9SJohnathan Mantey                                            "#/" + fieldName + "/"}});
94749c53ac9SJohnathan Mantey                 }
948de629b6eSShawn McCarney                 nlohmann::json& sensorJson = tempArray.back();
949de629b6eSShawn McCarney 
950de629b6eSShawn McCarney                 objectInterfacesToJson(sensorName, sensorType,
951de629b6eSShawn McCarney                                        objDictEntry.second, sensorJson);
952de629b6eSShawn McCarney             }
95349c53ac9SJohnathan Mantey             if (SensorsAsyncResp.use_count() == 1)
95449c53ac9SJohnathan Mantey             {
95549c53ac9SJohnathan Mantey                 sortJSONResponse(SensorsAsyncResp);
95649c53ac9SJohnathan Mantey                 if (SensorsAsyncResp->chassisSubNode == "Thermal")
9578bd25ccdSJames Feist                 {
9588bd25ccdSJames Feist                     populateFanRedundancy(SensorsAsyncResp);
9598bd25ccdSJames Feist                 }
96049c53ac9SJohnathan Mantey             }
961de629b6eSShawn McCarney             BMCWEB_LOG_DEBUG << "getManagedObjectsCb exit";
962de629b6eSShawn McCarney         };
963de629b6eSShawn McCarney 
964de629b6eSShawn McCarney         // Find DBus object path that implements ObjectManager for the current
965de629b6eSShawn McCarney         // connection.  If no mapping found, default to "/".
966de629b6eSShawn McCarney         auto iter = objectMgrPaths.find(connection);
967de629b6eSShawn McCarney         const std::string& objectMgrPath =
968de629b6eSShawn McCarney             (iter != objectMgrPaths.end()) ? iter->second : "/";
969de629b6eSShawn McCarney         BMCWEB_LOG_DEBUG << "ObjectManager path for " << connection << " is "
970de629b6eSShawn McCarney                          << objectMgrPath;
971de629b6eSShawn McCarney 
972de629b6eSShawn McCarney         crow::connections::systemBus->async_method_call(
973de629b6eSShawn McCarney             getManagedObjectsCb, connection, objectMgrPath,
974de629b6eSShawn McCarney             "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
975de629b6eSShawn McCarney     };
976de629b6eSShawn McCarney     BMCWEB_LOG_DEBUG << "getSensorData exit";
977de629b6eSShawn McCarney }
978de629b6eSShawn McCarney 
979de629b6eSShawn McCarney /**
98008777fb0SLewanczyk, Dawid  * @brief Entry point for retrieving sensors data related to requested
98108777fb0SLewanczyk, Dawid  *        chassis.
982588c3f0dSKowalski, Kamil  * @param SensorsAsyncResp   Pointer to object holding response data
98308777fb0SLewanczyk, Dawid  */
9841abe55efSEd Tanous void getChassisData(std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp)
9851abe55efSEd Tanous {
98655c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "getChassisData enter";
98749c53ac9SJohnathan Mantey     auto getChassisCb =
98849c53ac9SJohnathan Mantey         [SensorsAsyncResp](
98949c53ac9SJohnathan Mantey             std::shared_ptr<boost::container::flat_set<std::string>>
99008777fb0SLewanczyk, Dawid                 sensorNames) {
99155c7b7a2SEd Tanous             BMCWEB_LOG_DEBUG << "getChassisCb enter";
992588c3f0dSKowalski, Kamil             auto getConnectionCb =
99349c53ac9SJohnathan Mantey                 [SensorsAsyncResp,
99449c53ac9SJohnathan Mantey                  sensorNames](const boost::container::flat_set<std::string>&
99549c53ac9SJohnathan Mantey                                   connections) {
99655c7b7a2SEd Tanous                     BMCWEB_LOG_DEBUG << "getConnectionCb enter";
997de629b6eSShawn McCarney                     auto getObjectManagerPathsCb =
99849c53ac9SJohnathan Mantey                         [SensorsAsyncResp, sensorNames, connections](
99949c53ac9SJohnathan Mantey                             const boost::container::flat_map<
1000de629b6eSShawn McCarney                                 std::string, std::string>& objectMgrPaths) {
1001de629b6eSShawn McCarney                             BMCWEB_LOG_DEBUG << "getObjectManagerPathsCb enter";
100249c53ac9SJohnathan Mantey                             // Get sensor data and store results in JSON
100349c53ac9SJohnathan Mantey                             // response
1004de629b6eSShawn McCarney                             getSensorData(SensorsAsyncResp, sensorNames,
1005de629b6eSShawn McCarney                                           connections, objectMgrPaths);
1006de629b6eSShawn McCarney                             BMCWEB_LOG_DEBUG << "getObjectManagerPathsCb exit";
100708777fb0SLewanczyk, Dawid                         };
1008de629b6eSShawn McCarney 
100949c53ac9SJohnathan Mantey                     // Get mapping from connection names to the DBus object
101049c53ac9SJohnathan Mantey                     // paths that implement the ObjectManager interface
1011de629b6eSShawn McCarney                     getObjectManagerPaths(SensorsAsyncResp,
1012de629b6eSShawn McCarney                                           std::move(getObjectManagerPathsCb));
101355c7b7a2SEd Tanous                     BMCWEB_LOG_DEBUG << "getConnectionCb exit";
101408777fb0SLewanczyk, Dawid                 };
1015de629b6eSShawn McCarney 
1016de629b6eSShawn McCarney             // Get set of connections that provide sensor values
10171abe55efSEd Tanous             getConnections(SensorsAsyncResp, sensorNames,
10181abe55efSEd Tanous                            std::move(getConnectionCb));
101955c7b7a2SEd Tanous             BMCWEB_LOG_DEBUG << "getChassisCb exit";
102008777fb0SLewanczyk, Dawid         };
1021*4f9a2130SJennifer Lee     SensorsAsyncResp->res.jsonValue["Redundancy"] = nlohmann::json::array();
102208777fb0SLewanczyk, Dawid 
102326f03899SShawn McCarney     // Get set of sensors in chassis
1024588c3f0dSKowalski, Kamil     getChassis(SensorsAsyncResp, std::move(getChassisCb));
102555c7b7a2SEd Tanous     BMCWEB_LOG_DEBUG << "getChassisData exit";
102608777fb0SLewanczyk, Dawid };
102708777fb0SLewanczyk, Dawid 
1028413961deSRichard Marian Thomaiyar /**
102949c53ac9SJohnathan Mantey  * @brief Find the requested sensorName in the list of all sensors supplied by
103049c53ac9SJohnathan Mantey  * the chassis node
103149c53ac9SJohnathan Mantey  *
103249c53ac9SJohnathan Mantey  * @param sensorName   The sensor name supplied in the PATCH request
103349c53ac9SJohnathan Mantey  * @param sensorsList  The list of sensors managed by the chassis node
103449c53ac9SJohnathan Mantey  * @param sensorsModified  The list of sensors that were found as a result of
103549c53ac9SJohnathan Mantey  *                         repeated calls to this function
103649c53ac9SJohnathan Mantey  */
103749c53ac9SJohnathan Mantey bool findSensorNameUsingSensorPath(
103849c53ac9SJohnathan Mantey     const std::string& sensorName,
103949c53ac9SJohnathan Mantey     boost::container::flat_set<std::string>& sensorsList,
104049c53ac9SJohnathan Mantey     boost::container::flat_set<std::string>& sensorsModified)
104149c53ac9SJohnathan Mantey {
104249c53ac9SJohnathan Mantey     for (const std::string& chassisSensor : sensorsList)
104349c53ac9SJohnathan Mantey     {
104449c53ac9SJohnathan Mantey         std::string thisSensorName;
104549c53ac9SJohnathan Mantey         if (!dbus::utility::getNthStringFromPath(chassisSensor, 5,
104649c53ac9SJohnathan Mantey                                                  thisSensorName))
104749c53ac9SJohnathan Mantey         {
104849c53ac9SJohnathan Mantey             BMCWEB_LOG_ERROR << "Got path that isn't long enough "
104949c53ac9SJohnathan Mantey                              << chassisSensor;
105049c53ac9SJohnathan Mantey             continue;
105149c53ac9SJohnathan Mantey         }
105249c53ac9SJohnathan Mantey         if (thisSensorName == sensorName)
105349c53ac9SJohnathan Mantey         {
105449c53ac9SJohnathan Mantey             sensorsModified.emplace(chassisSensor);
105549c53ac9SJohnathan Mantey             return true;
105649c53ac9SJohnathan Mantey         }
105749c53ac9SJohnathan Mantey     }
105849c53ac9SJohnathan Mantey     return false;
105949c53ac9SJohnathan Mantey }
106049c53ac9SJohnathan Mantey 
106149c53ac9SJohnathan Mantey /**
1062413961deSRichard Marian Thomaiyar  * @brief Entry point for overriding sensor values of given sensor
1063413961deSRichard Marian Thomaiyar  *
1064413961deSRichard Marian Thomaiyar  * @param res   response object
1065413961deSRichard Marian Thomaiyar  * @param req   request object
1066413961deSRichard Marian Thomaiyar  * @param params   parameter passed for CRUD
1067413961deSRichard Marian Thomaiyar  * @param typeList   TypeList of sensors for the resource queried
1068413961deSRichard Marian Thomaiyar  * @param chassisSubNode   Chassis Node for which the query has to happen
1069413961deSRichard Marian Thomaiyar  */
1070413961deSRichard Marian Thomaiyar void setSensorOverride(crow::Response& res, const crow::Request& req,
1071413961deSRichard Marian Thomaiyar                        const std::vector<std::string>& params,
1072b01bf299SEd Tanous                        const std::initializer_list<const char*> typeList,
1073413961deSRichard Marian Thomaiyar                        const std::string& chassisSubNode)
1074413961deSRichard Marian Thomaiyar {
1075413961deSRichard Marian Thomaiyar 
1076413961deSRichard Marian Thomaiyar     // TODO: Need to figure out dynamic way to restrict patch (Set Sensor
1077413961deSRichard Marian Thomaiyar     // override) based on another d-bus announcement to be more generic.
1078413961deSRichard Marian Thomaiyar     if (params.size() != 1)
1079413961deSRichard Marian Thomaiyar     {
1080413961deSRichard Marian Thomaiyar         messages::internalError(res);
1081413961deSRichard Marian Thomaiyar         res.end();
1082413961deSRichard Marian Thomaiyar         return;
1083413961deSRichard Marian Thomaiyar     }
1084f65af9e8SRichard Marian Thomaiyar 
1085f65af9e8SRichard Marian Thomaiyar     std::unordered_map<std::string, std::vector<nlohmann::json>> allCollections;
1086f65af9e8SRichard Marian Thomaiyar     std::optional<std::vector<nlohmann::json>> temperatureCollections;
1087f65af9e8SRichard Marian Thomaiyar     std::optional<std::vector<nlohmann::json>> fanCollections;
1088f65af9e8SRichard Marian Thomaiyar     std::vector<nlohmann::json> voltageCollections;
1089f65af9e8SRichard Marian Thomaiyar     BMCWEB_LOG_INFO << "setSensorOverride for subNode" << chassisSubNode
1090f65af9e8SRichard Marian Thomaiyar                     << "\n";
1091f65af9e8SRichard Marian Thomaiyar 
1092413961deSRichard Marian Thomaiyar     if (chassisSubNode == "Thermal")
1093413961deSRichard Marian Thomaiyar     {
1094f65af9e8SRichard Marian Thomaiyar         if (!json_util::readJson(req, res, "Temperatures",
1095f65af9e8SRichard Marian Thomaiyar                                  temperatureCollections, "Fans",
1096f65af9e8SRichard Marian Thomaiyar                                  fanCollections))
1097f65af9e8SRichard Marian Thomaiyar         {
1098f65af9e8SRichard Marian Thomaiyar             return;
1099f65af9e8SRichard Marian Thomaiyar         }
1100f65af9e8SRichard Marian Thomaiyar         if (!temperatureCollections && !fanCollections)
1101f65af9e8SRichard Marian Thomaiyar         {
1102f65af9e8SRichard Marian Thomaiyar             messages::resourceNotFound(res, "Thermal",
1103f65af9e8SRichard Marian Thomaiyar                                        "Temperatures / Voltages");
1104f65af9e8SRichard Marian Thomaiyar             res.end();
1105f65af9e8SRichard Marian Thomaiyar             return;
1106f65af9e8SRichard Marian Thomaiyar         }
1107f65af9e8SRichard Marian Thomaiyar         if (temperatureCollections)
1108f65af9e8SRichard Marian Thomaiyar         {
1109f65af9e8SRichard Marian Thomaiyar             allCollections.emplace("Temperatures",
1110f65af9e8SRichard Marian Thomaiyar                                    *std::move(temperatureCollections));
1111f65af9e8SRichard Marian Thomaiyar         }
1112f65af9e8SRichard Marian Thomaiyar         if (fanCollections)
1113f65af9e8SRichard Marian Thomaiyar         {
1114f65af9e8SRichard Marian Thomaiyar             allCollections.emplace("Fans", *std::move(fanCollections));
1115f65af9e8SRichard Marian Thomaiyar         }
1116413961deSRichard Marian Thomaiyar     }
1117413961deSRichard Marian Thomaiyar     else if (chassisSubNode == "Power")
1118413961deSRichard Marian Thomaiyar     {
1119f65af9e8SRichard Marian Thomaiyar         if (!json_util::readJson(req, res, "Voltages", voltageCollections))
1120f65af9e8SRichard Marian Thomaiyar         {
1121f65af9e8SRichard Marian Thomaiyar             return;
1122f65af9e8SRichard Marian Thomaiyar         }
1123f65af9e8SRichard Marian Thomaiyar         allCollections.emplace("Voltages", std::move(voltageCollections));
1124413961deSRichard Marian Thomaiyar     }
1125413961deSRichard Marian Thomaiyar     else
1126413961deSRichard Marian Thomaiyar     {
1127413961deSRichard Marian Thomaiyar         res.result(boost::beast::http::status::not_found);
1128413961deSRichard Marian Thomaiyar         res.end();
1129413961deSRichard Marian Thomaiyar         return;
1130413961deSRichard Marian Thomaiyar     }
1131413961deSRichard Marian Thomaiyar 
1132f65af9e8SRichard Marian Thomaiyar     const char* propertyValueName;
1133f65af9e8SRichard Marian Thomaiyar     std::unordered_map<std::string, std::pair<double, std::string>> overrideMap;
1134413961deSRichard Marian Thomaiyar     std::string memberId;
1135413961deSRichard Marian Thomaiyar     double value;
1136f65af9e8SRichard Marian Thomaiyar     for (auto& collectionItems : allCollections)
1137f65af9e8SRichard Marian Thomaiyar     {
1138f65af9e8SRichard Marian Thomaiyar         if (collectionItems.first == "Temperatures")
1139f65af9e8SRichard Marian Thomaiyar         {
1140f65af9e8SRichard Marian Thomaiyar             propertyValueName = "ReadingCelsius";
1141f65af9e8SRichard Marian Thomaiyar         }
1142f65af9e8SRichard Marian Thomaiyar         else if (collectionItems.first == "Fans")
1143f65af9e8SRichard Marian Thomaiyar         {
1144f65af9e8SRichard Marian Thomaiyar             propertyValueName = "Reading";
1145f65af9e8SRichard Marian Thomaiyar         }
1146f65af9e8SRichard Marian Thomaiyar         else
1147f65af9e8SRichard Marian Thomaiyar         {
1148f65af9e8SRichard Marian Thomaiyar             propertyValueName = "ReadingVolts";
1149f65af9e8SRichard Marian Thomaiyar         }
1150f65af9e8SRichard Marian Thomaiyar         for (auto& item : collectionItems.second)
1151f65af9e8SRichard Marian Thomaiyar         {
1152f65af9e8SRichard Marian Thomaiyar             if (!json_util::readJson(item, res, "MemberId", memberId,
1153413961deSRichard Marian Thomaiyar                                      propertyValueName, value))
1154413961deSRichard Marian Thomaiyar             {
1155413961deSRichard Marian Thomaiyar                 return;
1156413961deSRichard Marian Thomaiyar             }
1157f65af9e8SRichard Marian Thomaiyar             overrideMap.emplace(memberId,
1158f65af9e8SRichard Marian Thomaiyar                                 std::make_pair(value, collectionItems.first));
1159f65af9e8SRichard Marian Thomaiyar         }
1160f65af9e8SRichard Marian Thomaiyar     }
1161413961deSRichard Marian Thomaiyar     const std::string& chassisName = params[0];
1162413961deSRichard Marian Thomaiyar     auto sensorAsyncResp = std::make_shared<SensorsAsyncResp>(
1163413961deSRichard Marian Thomaiyar         res, chassisName, typeList, chassisSubNode);
116449c53ac9SJohnathan Mantey     auto getChassisSensorListCb = [sensorAsyncResp,
116549c53ac9SJohnathan Mantey                                    overrideMap](const std::shared_ptr<
116649c53ac9SJohnathan Mantey                                                 boost::container::flat_set<
116749c53ac9SJohnathan Mantey                                                     std::string>>
116849c53ac9SJohnathan Mantey                                                     sensorsList) {
116949c53ac9SJohnathan Mantey         // Match sensor names in the PATCH request to those managed by the
117049c53ac9SJohnathan Mantey         // chassis node
117149c53ac9SJohnathan Mantey         const std::shared_ptr<boost::container::flat_set<std::string>>
117249c53ac9SJohnathan Mantey             sensorNames =
117349c53ac9SJohnathan Mantey                 std::make_shared<boost::container::flat_set<std::string>>();
1174f65af9e8SRichard Marian Thomaiyar         for (const auto& item : overrideMap)
1175413961deSRichard Marian Thomaiyar         {
1176f65af9e8SRichard Marian Thomaiyar             const auto& sensor = item.first;
117749c53ac9SJohnathan Mantey             if (!findSensorNameUsingSensorPath(sensor, *sensorsList,
117849c53ac9SJohnathan Mantey                                                *sensorNames))
1179f65af9e8SRichard Marian Thomaiyar             {
1180f65af9e8SRichard Marian Thomaiyar                 BMCWEB_LOG_INFO << "Unable to find memberId " << item.first;
1181413961deSRichard Marian Thomaiyar                 messages::resourceNotFound(sensorAsyncResp->res,
1182f65af9e8SRichard Marian Thomaiyar                                            item.second.second, item.first);
1183413961deSRichard Marian Thomaiyar                 return;
1184413961deSRichard Marian Thomaiyar             }
1185f65af9e8SRichard Marian Thomaiyar         }
1186413961deSRichard Marian Thomaiyar         // Get the connection to which the memberId belongs
1187413961deSRichard Marian Thomaiyar         auto getObjectsWithConnectionCb =
1188f65af9e8SRichard Marian Thomaiyar             [sensorAsyncResp, overrideMap](
1189413961deSRichard Marian Thomaiyar                 const boost::container::flat_set<std::string>& connections,
1190413961deSRichard Marian Thomaiyar                 const std::set<std::pair<std::string, std::string>>&
1191413961deSRichard Marian Thomaiyar                     objectsWithConnection) {
1192f65af9e8SRichard Marian Thomaiyar                 if (objectsWithConnection.size() != overrideMap.size())
1193413961deSRichard Marian Thomaiyar                 {
1194413961deSRichard Marian Thomaiyar                     BMCWEB_LOG_INFO
1195f65af9e8SRichard Marian Thomaiyar                         << "Unable to find all objects with proper connection "
1196f65af9e8SRichard Marian Thomaiyar                         << objectsWithConnection.size() << " requested "
1197f65af9e8SRichard Marian Thomaiyar                         << overrideMap.size() << "\n";
1198413961deSRichard Marian Thomaiyar                     messages::resourceNotFound(
1199413961deSRichard Marian Thomaiyar                         sensorAsyncResp->res,
1200413961deSRichard Marian Thomaiyar                         sensorAsyncResp->chassisSubNode == "Thermal"
1201413961deSRichard Marian Thomaiyar                             ? "Temperatures"
1202413961deSRichard Marian Thomaiyar                             : "Voltages",
1203f65af9e8SRichard Marian Thomaiyar                         "Count");
1204f65af9e8SRichard Marian Thomaiyar                     return;
1205f65af9e8SRichard Marian Thomaiyar                 }
1206f65af9e8SRichard Marian Thomaiyar                 for (const auto& item : objectsWithConnection)
1207f65af9e8SRichard Marian Thomaiyar                 {
1208f65af9e8SRichard Marian Thomaiyar 
1209f65af9e8SRichard Marian Thomaiyar                     auto lastPos = item.first.rfind('/');
1210f65af9e8SRichard Marian Thomaiyar                     if (lastPos == std::string::npos)
1211f65af9e8SRichard Marian Thomaiyar                     {
1212f65af9e8SRichard Marian Thomaiyar                         messages::internalError(sensorAsyncResp->res);
1213f65af9e8SRichard Marian Thomaiyar                         return;
1214f65af9e8SRichard Marian Thomaiyar                     }
1215f65af9e8SRichard Marian Thomaiyar                     std::string sensorName = item.first.substr(lastPos + 1);
1216f65af9e8SRichard Marian Thomaiyar 
1217f65af9e8SRichard Marian Thomaiyar                     const auto& iterator = overrideMap.find(sensorName);
1218f65af9e8SRichard Marian Thomaiyar                     if (iterator == overrideMap.end())
1219f65af9e8SRichard Marian Thomaiyar                     {
1220f65af9e8SRichard Marian Thomaiyar                         BMCWEB_LOG_INFO << "Unable to find sensor object"
1221f65af9e8SRichard Marian Thomaiyar                                         << item.first << "\n";
1222f65af9e8SRichard Marian Thomaiyar                         messages::internalError(sensorAsyncResp->res);
1223413961deSRichard Marian Thomaiyar                         return;
1224413961deSRichard Marian Thomaiyar                     }
1225413961deSRichard Marian Thomaiyar                     crow::connections::systemBus->async_method_call(
1226f65af9e8SRichard Marian Thomaiyar                         [sensorAsyncResp](const boost::system::error_code ec) {
1227413961deSRichard Marian Thomaiyar                             if (ec)
1228413961deSRichard Marian Thomaiyar                             {
1229413961deSRichard Marian Thomaiyar                                 BMCWEB_LOG_DEBUG
1230f65af9e8SRichard Marian Thomaiyar                                     << "setOverrideValueStatus DBUS error: "
1231413961deSRichard Marian Thomaiyar                                     << ec;
1232413961deSRichard Marian Thomaiyar                                 messages::internalError(sensorAsyncResp->res);
1233413961deSRichard Marian Thomaiyar                                 return;
1234413961deSRichard Marian Thomaiyar                             }
1235413961deSRichard Marian Thomaiyar                         },
1236f65af9e8SRichard Marian Thomaiyar                         item.second, item.first,
1237413961deSRichard Marian Thomaiyar                         "org.freedesktop.DBus.Properties", "Set",
1238413961deSRichard Marian Thomaiyar                         "xyz.openbmc_project.Sensor.Value", "Value",
1239f65af9e8SRichard Marian Thomaiyar                         sdbusplus::message::variant<double>(
1240f65af9e8SRichard Marian Thomaiyar                             iterator->second.first));
1241f65af9e8SRichard Marian Thomaiyar                 }
1242413961deSRichard Marian Thomaiyar             };
1243413961deSRichard Marian Thomaiyar         // Get object with connection for the given sensor name
1244413961deSRichard Marian Thomaiyar         getObjectsWithConnection(sensorAsyncResp, sensorNames,
1245413961deSRichard Marian Thomaiyar                                  std::move(getObjectsWithConnectionCb));
1246413961deSRichard Marian Thomaiyar     };
1247413961deSRichard Marian Thomaiyar     // get full sensor list for the given chassisId and cross verify the sensor.
1248413961deSRichard Marian Thomaiyar     getChassis(sensorAsyncResp, std::move(getChassisSensorListCb));
1249413961deSRichard Marian Thomaiyar }
1250413961deSRichard Marian Thomaiyar 
125108777fb0SLewanczyk, Dawid } // namespace redfish
1252