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