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"; 27649c53ac9SJohnathan Mantey } 27749c53ac9SJohnathan Mantey sensorsAsyncResp->res.jsonValue["@odata.id"] = 27849c53ac9SJohnathan Mantey "/redfish/v1/Chassis/" + sensorsAsyncResp->chassisId + "/" + 27949c53ac9SJohnathan Mantey chassisSubNode; 28049c53ac9SJohnathan Mantey 28149c53ac9SJohnathan Mantey sensorsAsyncResp->res.jsonValue["@odata.context"] = 28249c53ac9SJohnathan Mantey "/redfish/v1/$metadata#" + chassisSubNode + "." + chassisSubNode; 28349c53ac9SJohnathan Mantey sensorsAsyncResp->res.jsonValue["Id"] = chassisSubNode; 28449c53ac9SJohnathan Mantey sensorsAsyncResp->res.jsonValue["Name"] = chassisSubNode; 28549c53ac9SJohnathan Mantey 28649c53ac9SJohnathan Mantey // Get the list of sensors for this Chassis element 28749c53ac9SJohnathan Mantey std::string sensorPath = *chassisPath + "/sensors"; 28855c7b7a2SEd Tanous crow::connections::systemBus->async_method_call( 28949c53ac9SJohnathan Mantey [sensorsAsyncResp, callback{std::move(callback)}]( 29049c53ac9SJohnathan Mantey const boost::system::error_code ec, 29149c53ac9SJohnathan Mantey const std::variant<std::vector<std::string>>& 29249c53ac9SJohnathan Mantey variantEndpoints) { 29349c53ac9SJohnathan Mantey if (ec) 29449c53ac9SJohnathan Mantey { 29549c53ac9SJohnathan Mantey if (ec.value() != EBADR) 29649c53ac9SJohnathan Mantey { 29749c53ac9SJohnathan Mantey messages::internalError(sensorsAsyncResp->res); 29849c53ac9SJohnathan Mantey return; 29949c53ac9SJohnathan Mantey } 30049c53ac9SJohnathan Mantey } 30149c53ac9SJohnathan Mantey const std::vector<std::string>* nodeSensorList = 30249c53ac9SJohnathan Mantey std::get_if<std::vector<std::string>>(&(variantEndpoints)); 30349c53ac9SJohnathan Mantey if (nodeSensorList == nullptr) 30449c53ac9SJohnathan Mantey { 30549c53ac9SJohnathan Mantey messages::resourceNotFound( 30649c53ac9SJohnathan Mantey sensorsAsyncResp->res, sensorsAsyncResp->chassisSubNode, 30749c53ac9SJohnathan Mantey sensorsAsyncResp->chassisSubNode == "Thermal" 30849c53ac9SJohnathan Mantey ? "Temperatures" 30949c53ac9SJohnathan Mantey : "Voltages"); 31049c53ac9SJohnathan Mantey return; 31149c53ac9SJohnathan Mantey } 31249c53ac9SJohnathan Mantey const std::shared_ptr<boost::container::flat_set<std::string>> 31349c53ac9SJohnathan Mantey culledSensorList = std::make_shared< 31449c53ac9SJohnathan Mantey boost::container::flat_set<std::string>>(); 31549c53ac9SJohnathan Mantey reduceSensorList(sensorsAsyncResp, nodeSensorList, 31649c53ac9SJohnathan Mantey culledSensorList); 31749c53ac9SJohnathan Mantey callback(culledSensorList); 31849c53ac9SJohnathan Mantey }, 31949c53ac9SJohnathan Mantey "xyz.openbmc_project.ObjectMapper", sensorPath, 32049c53ac9SJohnathan Mantey "org.freedesktop.DBus.Properties", "Get", 32149c53ac9SJohnathan Mantey "xyz.openbmc_project.Association", "endpoints"); 32249c53ac9SJohnathan Mantey }; 32349c53ac9SJohnathan Mantey 32449c53ac9SJohnathan Mantey // Get the Chassis Collection 32549c53ac9SJohnathan Mantey crow::connections::systemBus->async_method_call( 32649c53ac9SJohnathan Mantey respHandler, "xyz.openbmc_project.ObjectMapper", 32749c53ac9SJohnathan Mantey "/xyz/openbmc_project/object_mapper", 32849c53ac9SJohnathan Mantey "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", 32949c53ac9SJohnathan Mantey "/xyz/openbmc_project/inventory", int32_t(0), interfaces); 33055c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "getChassis exit"; 33108777fb0SLewanczyk, Dawid } 33208777fb0SLewanczyk, Dawid 33308777fb0SLewanczyk, Dawid /** 334de629b6eSShawn McCarney * @brief Finds all DBus object paths that implement ObjectManager. 335de629b6eSShawn McCarney * 336de629b6eSShawn McCarney * Creates a mapping from the associated connection name to the object path. 337de629b6eSShawn McCarney * 338de629b6eSShawn McCarney * Finds the object paths asynchronously. Invokes callback when information has 339de629b6eSShawn McCarney * been obtained. 340de629b6eSShawn McCarney * 341de629b6eSShawn McCarney * The callback must have the following signature: 342de629b6eSShawn McCarney * @code 343de629b6eSShawn McCarney * callback(const boost::container::flat_map<std::string, 344de629b6eSShawn McCarney * std::string>& objectMgrPaths) 345de629b6eSShawn McCarney * @endcode 346de629b6eSShawn McCarney * 34749c53ac9SJohnathan Mantey * @param sensorsAsyncResp Pointer to object holding response data. 348de629b6eSShawn McCarney * @param callback Callback to invoke when object paths obtained. 349de629b6eSShawn McCarney */ 350de629b6eSShawn McCarney template <typename Callback> 351de629b6eSShawn McCarney void getObjectManagerPaths(std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp, 352de629b6eSShawn McCarney Callback&& callback) 353de629b6eSShawn McCarney { 354de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getObjectManagerPaths enter"; 355de629b6eSShawn McCarney const std::array<std::string, 1> interfaces = { 356de629b6eSShawn McCarney "org.freedesktop.DBus.ObjectManager"}; 357de629b6eSShawn McCarney 358de629b6eSShawn McCarney // Response handler for GetSubTree DBus method 359de629b6eSShawn McCarney auto respHandler = [callback{std::move(callback)}, 360de629b6eSShawn McCarney SensorsAsyncResp](const boost::system::error_code ec, 361de629b6eSShawn McCarney const GetSubTreeType& subtree) { 362de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getObjectManagerPaths respHandler enter"; 363de629b6eSShawn McCarney if (ec) 364de629b6eSShawn McCarney { 365de629b6eSShawn McCarney messages::internalError(SensorsAsyncResp->res); 366de629b6eSShawn McCarney BMCWEB_LOG_ERROR << "getObjectManagerPaths respHandler: DBus error " 367de629b6eSShawn McCarney << ec; 368de629b6eSShawn McCarney return; 369de629b6eSShawn McCarney } 370de629b6eSShawn McCarney 371de629b6eSShawn McCarney // Loop over returned object paths 372de629b6eSShawn McCarney boost::container::flat_map<std::string, std::string> objectMgrPaths; 373de629b6eSShawn McCarney for (const std::pair< 374de629b6eSShawn McCarney std::string, 375de629b6eSShawn McCarney std::vector<std::pair<std::string, std::vector<std::string>>>>& 376de629b6eSShawn McCarney object : subtree) 377de629b6eSShawn McCarney { 378de629b6eSShawn McCarney // Loop over connections for current object path 379de629b6eSShawn McCarney const std::string& objectPath = object.first; 380de629b6eSShawn McCarney for (const std::pair<std::string, std::vector<std::string>>& 381de629b6eSShawn McCarney objData : object.second) 382de629b6eSShawn McCarney { 383de629b6eSShawn McCarney // Add mapping from connection to object path 384de629b6eSShawn McCarney const std::string& connection = objData.first; 385de629b6eSShawn McCarney objectMgrPaths[connection] = objectPath; 386de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "Added mapping " << connection << " -> " 387de629b6eSShawn McCarney << objectPath; 388de629b6eSShawn McCarney } 389de629b6eSShawn McCarney } 390de629b6eSShawn McCarney callback(std::move(objectMgrPaths)); 391de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getObjectManagerPaths respHandler exit"; 392de629b6eSShawn McCarney }; 393de629b6eSShawn McCarney 394de629b6eSShawn McCarney // Query mapper for all DBus object paths that implement ObjectManager 395de629b6eSShawn McCarney crow::connections::systemBus->async_method_call( 396de629b6eSShawn McCarney std::move(respHandler), "xyz.openbmc_project.ObjectMapper", 397de629b6eSShawn McCarney "/xyz/openbmc_project/object_mapper", 398de629b6eSShawn McCarney "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", int32_t(0), 399de629b6eSShawn McCarney interfaces); 400de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getObjectManagerPaths exit"; 401de629b6eSShawn McCarney } 402de629b6eSShawn McCarney 403de629b6eSShawn McCarney /** 40408777fb0SLewanczyk, Dawid * @brief Builds a json sensor representation of a sensor. 40508777fb0SLewanczyk, Dawid * @param sensorName The name of the sensor to be built 406274fad5aSGunnar Mills * @param sensorType The type (temperature, fan_tach, etc) of the sensor to 40708777fb0SLewanczyk, Dawid * build 40808777fb0SLewanczyk, Dawid * @param interfacesDict A dictionary of the interfaces and properties of said 40908777fb0SLewanczyk, Dawid * interfaces to be built from 41008777fb0SLewanczyk, Dawid * @param sensor_json The json object to fill 41108777fb0SLewanczyk, Dawid */ 41208777fb0SLewanczyk, Dawid void objectInterfacesToJson( 41308777fb0SLewanczyk, Dawid const std::string& sensorName, const std::string& sensorType, 41408777fb0SLewanczyk, Dawid const boost::container::flat_map< 415aa2e59c1SEd Tanous std::string, boost::container::flat_map<std::string, SensorVariant>>& 41608777fb0SLewanczyk, Dawid interfacesDict, 4171abe55efSEd Tanous nlohmann::json& sensor_json) 4181abe55efSEd Tanous { 41908777fb0SLewanczyk, Dawid // We need a value interface before we can do anything with it 42055c7b7a2SEd Tanous auto valueIt = interfacesDict.find("xyz.openbmc_project.Sensor.Value"); 4211abe55efSEd Tanous if (valueIt == interfacesDict.end()) 4221abe55efSEd Tanous { 42355c7b7a2SEd Tanous BMCWEB_LOG_ERROR << "Sensor doesn't have a value interface"; 42408777fb0SLewanczyk, Dawid return; 42508777fb0SLewanczyk, Dawid } 42608777fb0SLewanczyk, Dawid 42708777fb0SLewanczyk, Dawid // Assume values exist as is (10^0 == 1) if no scale exists 42808777fb0SLewanczyk, Dawid int64_t scaleMultiplier = 0; 42908777fb0SLewanczyk, Dawid 43055c7b7a2SEd Tanous auto scaleIt = valueIt->second.find("Scale"); 43108777fb0SLewanczyk, Dawid // If a scale exists, pull value as int64, and use the scaling. 4321abe55efSEd Tanous if (scaleIt != valueIt->second.end()) 4331abe55efSEd Tanous { 434abf2add6SEd Tanous const int64_t* int64Value = std::get_if<int64_t>(&scaleIt->second); 4351abe55efSEd Tanous if (int64Value != nullptr) 4361abe55efSEd Tanous { 43708777fb0SLewanczyk, Dawid scaleMultiplier = *int64Value; 43808777fb0SLewanczyk, Dawid } 43908777fb0SLewanczyk, Dawid } 44008777fb0SLewanczyk, Dawid 44108777fb0SLewanczyk, Dawid sensor_json["MemberId"] = sensorName; 44208777fb0SLewanczyk, Dawid sensor_json["Name"] = sensorName; 44308777fb0SLewanczyk, Dawid sensor_json["Status"]["State"] = "Enabled"; 44408777fb0SLewanczyk, Dawid sensor_json["Status"]["Health"] = "OK"; 44508777fb0SLewanczyk, Dawid 44608777fb0SLewanczyk, Dawid // Parameter to set to override the type we get from dbus, and force it to 44708777fb0SLewanczyk, Dawid // int, regardless of what is available. This is used for schemas like fan, 44808777fb0SLewanczyk, Dawid // that require integers, not floats. 44908777fb0SLewanczyk, Dawid bool forceToInt = false; 45008777fb0SLewanczyk, Dawid 45108777fb0SLewanczyk, Dawid const char* unit = "Reading"; 4521abe55efSEd Tanous if (sensorType == "temperature") 4531abe55efSEd Tanous { 45408777fb0SLewanczyk, Dawid unit = "ReadingCelsius"; 4557885954aSLewanczyk, Dawid sensor_json["@odata.type"] = "#Thermal.v1_3_0.Temperature"; 45608777fb0SLewanczyk, Dawid // TODO(ed) Documentation says that path should be type fan_tach, 45708777fb0SLewanczyk, Dawid // implementation seems to implement fan 4581abe55efSEd Tanous } 4591abe55efSEd Tanous else if (sensorType == "fan" || sensorType == "fan_tach") 4601abe55efSEd Tanous { 46108777fb0SLewanczyk, Dawid unit = "Reading"; 46208777fb0SLewanczyk, Dawid sensor_json["ReadingUnits"] = "RPM"; 4637885954aSLewanczyk, Dawid sensor_json["@odata.type"] = "#Thermal.v1_3_0.Fan"; 46408777fb0SLewanczyk, Dawid forceToInt = true; 4651abe55efSEd Tanous } 4666f6d0d32SEd Tanous else if (sensorType == "fan_pwm") 4676f6d0d32SEd Tanous { 4686f6d0d32SEd Tanous unit = "Reading"; 4696f6d0d32SEd Tanous sensor_json["ReadingUnits"] = "Percent"; 4706f6d0d32SEd Tanous sensor_json["@odata.type"] = "#Thermal.v1_3_0.Fan"; 4716f6d0d32SEd Tanous forceToInt = true; 4726f6d0d32SEd Tanous } 4731abe55efSEd Tanous else if (sensorType == "voltage") 4741abe55efSEd Tanous { 47508777fb0SLewanczyk, Dawid unit = "ReadingVolts"; 4767885954aSLewanczyk, Dawid sensor_json["@odata.type"] = "#Power.v1_0_0.Voltage"; 4771abe55efSEd Tanous } 4782474adfaSEd Tanous else if (sensorType == "power") 4792474adfaSEd Tanous { 48049c53ac9SJohnathan Mantey std::string sensorNameLower = 48149c53ac9SJohnathan Mantey boost::algorithm::to_lower_copy(sensorName); 48249c53ac9SJohnathan Mantey 48349c53ac9SJohnathan Mantey if (sensorNameLower.find("input") != std::string::npos) 48449c53ac9SJohnathan Mantey { 48549c53ac9SJohnathan Mantey unit = "PowerInputWatts"; 48649c53ac9SJohnathan Mantey } 48749c53ac9SJohnathan Mantey else 48849c53ac9SJohnathan Mantey { 48949c53ac9SJohnathan Mantey unit = "PowerOutputWatts"; 49049c53ac9SJohnathan Mantey } 4912474adfaSEd Tanous } 4921abe55efSEd Tanous else 4931abe55efSEd Tanous { 49455c7b7a2SEd Tanous BMCWEB_LOG_ERROR << "Redfish cannot map object type for " << sensorName; 49508777fb0SLewanczyk, Dawid return; 49608777fb0SLewanczyk, Dawid } 49708777fb0SLewanczyk, Dawid // Map of dbus interface name, dbus property name and redfish property_name 49808777fb0SLewanczyk, Dawid std::vector<std::tuple<const char*, const char*, const char*>> properties; 49908777fb0SLewanczyk, Dawid properties.reserve(7); 50008777fb0SLewanczyk, Dawid 50108777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Value", "Value", unit); 502de629b6eSShawn McCarney 503de629b6eSShawn McCarney // If sensor type doesn't map to Redfish PowerSupply, add threshold props 504de629b6eSShawn McCarney if ((sensorType != "current") && (sensorType != "power")) 505de629b6eSShawn McCarney { 50608777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Warning", 50708777fb0SLewanczyk, Dawid "WarningHigh", "UpperThresholdNonCritical"); 50808777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Warning", 50908777fb0SLewanczyk, Dawid "WarningLow", "LowerThresholdNonCritical"); 51008777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Critical", 51108777fb0SLewanczyk, Dawid "CriticalHigh", "UpperThresholdCritical"); 51208777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Threshold.Critical", 51308777fb0SLewanczyk, Dawid "CriticalLow", "LowerThresholdCritical"); 514de629b6eSShawn McCarney } 51508777fb0SLewanczyk, Dawid 5162474adfaSEd Tanous // TODO Need to get UpperThresholdFatal and LowerThresholdFatal 5172474adfaSEd Tanous 5181abe55efSEd Tanous if (sensorType == "temperature") 5191abe55efSEd Tanous { 52008777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MinValue", 52108777fb0SLewanczyk, Dawid "MinReadingRangeTemp"); 52208777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MaxValue", 52308777fb0SLewanczyk, Dawid "MaxReadingRangeTemp"); 5241abe55efSEd Tanous } 525de629b6eSShawn McCarney else if ((sensorType != "current") && (sensorType != "power")) 5261abe55efSEd Tanous { 527de629b6eSShawn McCarney // Sensor type doesn't map to Redfish PowerSupply; add min/max props 52808777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MinValue", 52908777fb0SLewanczyk, Dawid "MinReadingRange"); 53008777fb0SLewanczyk, Dawid properties.emplace_back("xyz.openbmc_project.Sensor.Value", "MaxValue", 53108777fb0SLewanczyk, Dawid "MaxReadingRange"); 53208777fb0SLewanczyk, Dawid } 53308777fb0SLewanczyk, Dawid 53408777fb0SLewanczyk, Dawid for (const std::tuple<const char*, const char*, const char*>& p : 5351abe55efSEd Tanous properties) 5361abe55efSEd Tanous { 53708777fb0SLewanczyk, Dawid auto interfaceProperties = interfacesDict.find(std::get<0>(p)); 5381abe55efSEd Tanous if (interfaceProperties != interfacesDict.end()) 5391abe55efSEd Tanous { 540b01bf299SEd Tanous auto valueIt = interfaceProperties->second.find(std::get<1>(p)); 541b01bf299SEd Tanous if (valueIt != interfaceProperties->second.end()) 5421abe55efSEd Tanous { 543b01bf299SEd Tanous const SensorVariant& valueVariant = valueIt->second; 544b01bf299SEd Tanous nlohmann::json& valueIt = sensor_json[std::get<2>(p)]; 54508777fb0SLewanczyk, Dawid // Attempt to pull the int64 directly 546abf2add6SEd Tanous const int64_t* int64Value = std::get_if<int64_t>(&valueVariant); 54708777fb0SLewanczyk, Dawid 548abf2add6SEd Tanous const double* doubleValue = std::get_if<double>(&valueVariant); 5496f6d0d32SEd Tanous double temp = 0.0; 5506f6d0d32SEd Tanous if (int64Value != nullptr) 5511abe55efSEd Tanous { 5526f6d0d32SEd Tanous temp = *int64Value; 5536f6d0d32SEd Tanous } 5546f6d0d32SEd Tanous else if (doubleValue != nullptr) 5551abe55efSEd Tanous { 5566f6d0d32SEd Tanous temp = *doubleValue; 5571abe55efSEd Tanous } 5581abe55efSEd Tanous else 5591abe55efSEd Tanous { 5606f6d0d32SEd Tanous BMCWEB_LOG_ERROR 5616f6d0d32SEd Tanous << "Got value interface that wasn't int or double"; 5626f6d0d32SEd Tanous continue; 56308777fb0SLewanczyk, Dawid } 5646f6d0d32SEd Tanous temp = temp * std::pow(10, scaleMultiplier); 5656f6d0d32SEd Tanous if (forceToInt) 5666f6d0d32SEd Tanous { 567b01bf299SEd Tanous valueIt = static_cast<int64_t>(temp); 5686f6d0d32SEd Tanous } 5696f6d0d32SEd Tanous else 5706f6d0d32SEd Tanous { 571b01bf299SEd Tanous valueIt = temp; 57208777fb0SLewanczyk, Dawid } 57308777fb0SLewanczyk, Dawid } 57408777fb0SLewanczyk, Dawid } 57508777fb0SLewanczyk, Dawid } 57655c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "Added sensor " << sensorName; 57708777fb0SLewanczyk, Dawid } 57808777fb0SLewanczyk, Dawid 5798bd25ccdSJames Feist static void 5808bd25ccdSJames Feist populateFanRedundancy(std::shared_ptr<SensorsAsyncResp> sensorsAsyncResp) 5818bd25ccdSJames Feist { 5828bd25ccdSJames Feist crow::connections::systemBus->async_method_call( 5838bd25ccdSJames Feist [sensorsAsyncResp](const boost::system::error_code ec, 5848bd25ccdSJames Feist const GetSubTreeType& resp) { 5858bd25ccdSJames Feist if (ec) 5868bd25ccdSJames Feist { 5878bd25ccdSJames Feist return; // don't have to have this interface 5888bd25ccdSJames Feist } 589e278c18fSEd Tanous for (const std::pair<std::string, 590e278c18fSEd Tanous std::vector<std::pair< 591e278c18fSEd Tanous std::string, std::vector<std::string>>>>& 592e278c18fSEd Tanous pathPair : resp) 5938bd25ccdSJames Feist { 594e278c18fSEd Tanous const std::string& path = pathPair.first; 595e278c18fSEd Tanous const std::vector< 596e278c18fSEd Tanous std::pair<std::string, std::vector<std::string>>>& objDict = 597e278c18fSEd Tanous pathPair.second; 5988bd25ccdSJames Feist if (objDict.empty()) 5998bd25ccdSJames Feist { 6008bd25ccdSJames Feist continue; // this should be impossible 6018bd25ccdSJames Feist } 6028bd25ccdSJames Feist 6038bd25ccdSJames Feist const std::string& owner = objDict.begin()->first; 6048bd25ccdSJames Feist crow::connections::systemBus->async_method_call( 6058bd25ccdSJames Feist [path, owner, 6068bd25ccdSJames Feist sensorsAsyncResp](const boost::system::error_code ec, 6078bd25ccdSJames Feist std::variant<std::vector<std::string>> 6088bd25ccdSJames Feist variantEndpoints) { 6098bd25ccdSJames Feist if (ec) 6108bd25ccdSJames Feist { 6118bd25ccdSJames Feist return; // if they don't have an association we 6128bd25ccdSJames Feist // can't tell what chassis is 6138bd25ccdSJames Feist } 6148bd25ccdSJames Feist // verify part of the right chassis 6158bd25ccdSJames Feist auto endpoints = std::get_if<std::vector<std::string>>( 6168bd25ccdSJames Feist &variantEndpoints); 6178bd25ccdSJames Feist 6188bd25ccdSJames Feist if (endpoints == nullptr) 6198bd25ccdSJames Feist { 6208bd25ccdSJames Feist BMCWEB_LOG_ERROR << "Invalid association interface"; 6218bd25ccdSJames Feist messages::internalError(sensorsAsyncResp->res); 6228bd25ccdSJames Feist return; 6238bd25ccdSJames Feist } 6248bd25ccdSJames Feist 6258bd25ccdSJames Feist auto found = std::find_if( 6268bd25ccdSJames Feist endpoints->begin(), endpoints->end(), 6278bd25ccdSJames Feist [sensorsAsyncResp](const std::string& entry) { 6288bd25ccdSJames Feist return entry.find( 6298bd25ccdSJames Feist sensorsAsyncResp->chassisId) != 6308bd25ccdSJames Feist std::string::npos; 6318bd25ccdSJames Feist }); 6328bd25ccdSJames Feist 6338bd25ccdSJames Feist if (found == endpoints->end()) 6348bd25ccdSJames Feist { 6358bd25ccdSJames Feist return; 6368bd25ccdSJames Feist } 6378bd25ccdSJames Feist crow::connections::systemBus->async_method_call( 6388bd25ccdSJames Feist [path, sensorsAsyncResp]( 6398bd25ccdSJames Feist const boost::system::error_code ec, 6408bd25ccdSJames Feist const boost::container::flat_map< 6418bd25ccdSJames Feist std::string, 6428bd25ccdSJames Feist std::variant<uint8_t, 6438bd25ccdSJames Feist std::vector<std::string>, 6448bd25ccdSJames Feist std::string>>& ret) { 6458bd25ccdSJames Feist if (ec) 6468bd25ccdSJames Feist { 6478bd25ccdSJames Feist return; // don't have to have this 6488bd25ccdSJames Feist // interface 6498bd25ccdSJames Feist } 6508bd25ccdSJames Feist auto findFailures = ret.find("AllowedFailures"); 6518bd25ccdSJames Feist auto findCollection = ret.find("Collection"); 6528bd25ccdSJames Feist auto findStatus = ret.find("Status"); 6538bd25ccdSJames Feist 6548bd25ccdSJames Feist if (findFailures == ret.end() || 6558bd25ccdSJames Feist findCollection == ret.end() || 6568bd25ccdSJames Feist findStatus == ret.end()) 6578bd25ccdSJames Feist { 6588bd25ccdSJames Feist BMCWEB_LOG_ERROR 6598bd25ccdSJames Feist << "Invalid redundancy interface"; 6608bd25ccdSJames Feist messages::internalError( 6618bd25ccdSJames Feist sensorsAsyncResp->res); 6628bd25ccdSJames Feist return; 6638bd25ccdSJames Feist } 6648bd25ccdSJames Feist 6658bd25ccdSJames Feist auto allowedFailures = std::get_if<uint8_t>( 6668bd25ccdSJames Feist &(findFailures->second)); 6678bd25ccdSJames Feist auto collection = 6688bd25ccdSJames Feist std::get_if<std::vector<std::string>>( 6698bd25ccdSJames Feist &(findCollection->second)); 6708bd25ccdSJames Feist auto status = std::get_if<std::string>( 6718bd25ccdSJames Feist &(findStatus->second)); 6728bd25ccdSJames Feist 6738bd25ccdSJames Feist if (allowedFailures == nullptr || 6748bd25ccdSJames Feist collection == nullptr || status == nullptr) 6758bd25ccdSJames Feist { 6768bd25ccdSJames Feist 6778bd25ccdSJames Feist BMCWEB_LOG_ERROR 6788bd25ccdSJames Feist << "Invalid redundancy interface " 6798bd25ccdSJames Feist "types"; 6808bd25ccdSJames Feist messages::internalError( 6818bd25ccdSJames Feist sensorsAsyncResp->res); 6828bd25ccdSJames Feist return; 6838bd25ccdSJames Feist } 6848bd25ccdSJames Feist size_t lastSlash = path.rfind("/"); 6858bd25ccdSJames Feist if (lastSlash == std::string::npos) 6868bd25ccdSJames Feist { 6878bd25ccdSJames Feist // this should be impossible 6888bd25ccdSJames Feist messages::internalError( 6898bd25ccdSJames Feist sensorsAsyncResp->res); 6908bd25ccdSJames Feist return; 6918bd25ccdSJames Feist } 6928bd25ccdSJames Feist std::string name = path.substr(lastSlash + 1); 6938bd25ccdSJames Feist std::replace(name.begin(), name.end(), '_', 6948bd25ccdSJames Feist ' '); 6958bd25ccdSJames Feist 6968bd25ccdSJames Feist std::string health; 6978bd25ccdSJames Feist 6988bd25ccdSJames Feist if (boost::ends_with(*status, "Full")) 6998bd25ccdSJames Feist { 7008bd25ccdSJames Feist health = "OK"; 7018bd25ccdSJames Feist } 7028bd25ccdSJames Feist else if (boost::ends_with(*status, "Degraded")) 7038bd25ccdSJames Feist { 7048bd25ccdSJames Feist health = "Warning"; 7058bd25ccdSJames Feist } 7068bd25ccdSJames Feist else 7078bd25ccdSJames Feist { 7088bd25ccdSJames Feist health = "Critical"; 7098bd25ccdSJames Feist } 7108bd25ccdSJames Feist std::vector<nlohmann::json> redfishCollection; 7118bd25ccdSJames Feist const auto& fanRedfish = 7128bd25ccdSJames Feist sensorsAsyncResp->res.jsonValue["Fans"]; 7138bd25ccdSJames Feist for (const std::string& item : *collection) 7148bd25ccdSJames Feist { 7158bd25ccdSJames Feist lastSlash = item.rfind("/"); 7168bd25ccdSJames Feist // make a copy as collection is const 7178bd25ccdSJames Feist std::string itemName = 7188bd25ccdSJames Feist item.substr(lastSlash + 1); 7198bd25ccdSJames Feist /* 7208bd25ccdSJames Feist todo(ed): merge patch that fixes the names 7218bd25ccdSJames Feist std::replace(itemName.begin(), 7228bd25ccdSJames Feist itemName.end(), '_', ' ');*/ 7238bd25ccdSJames Feist auto schemaItem = std::find_if( 7248bd25ccdSJames Feist fanRedfish.begin(), fanRedfish.end(), 7258bd25ccdSJames Feist [itemName](const nlohmann::json& fan) { 7268bd25ccdSJames Feist return fan["MemberId"] == itemName; 7278bd25ccdSJames Feist }); 7288bd25ccdSJames Feist if (schemaItem != fanRedfish.end()) 7298bd25ccdSJames Feist { 7308bd25ccdSJames Feist redfishCollection.push_back( 7318bd25ccdSJames Feist {{"@odata.id", 7328bd25ccdSJames Feist (*schemaItem)["@odata.id"]}}); 7338bd25ccdSJames Feist } 7348bd25ccdSJames Feist else 7358bd25ccdSJames Feist { 7368bd25ccdSJames Feist BMCWEB_LOG_ERROR 7378bd25ccdSJames Feist << "failed to find fan in schema"; 7388bd25ccdSJames Feist messages::internalError( 7398bd25ccdSJames Feist sensorsAsyncResp->res); 7408bd25ccdSJames Feist return; 7418bd25ccdSJames Feist } 7428bd25ccdSJames Feist } 7438bd25ccdSJames Feist 7448bd25ccdSJames Feist auto& resp = sensorsAsyncResp->res 7458bd25ccdSJames Feist .jsonValue["Redundancy"]; 7468bd25ccdSJames Feist resp.push_back( 7478bd25ccdSJames Feist {{"@odata.id", 7488bd25ccdSJames Feist "/refish/v1/Chassis/" + 7498bd25ccdSJames Feist sensorsAsyncResp->chassisId + "/" + 7508bd25ccdSJames Feist sensorsAsyncResp->chassisSubNode + 7518bd25ccdSJames Feist "#/Redundancy/" + 7528bd25ccdSJames Feist std::to_string(resp.size())}, 7538bd25ccdSJames Feist {"@odata.type", 7548bd25ccdSJames Feist "#Redundancy.v1_3_2.Redundancy"}, 7558bd25ccdSJames Feist {"MinNumNeeded", 7568bd25ccdSJames Feist collection->size() - *allowedFailures}, 7578bd25ccdSJames Feist {"MemberId", name}, 7588bd25ccdSJames Feist {"Mode", "N+m"}, 7598bd25ccdSJames Feist {"Name", name}, 7608bd25ccdSJames Feist {"RedundancySet", redfishCollection}, 7618bd25ccdSJames Feist {"Status", 7628bd25ccdSJames Feist {{"Health", health}, 7638bd25ccdSJames Feist {"State", "Enabled"}}}}); 7648bd25ccdSJames Feist }, 7658bd25ccdSJames Feist owner, path, "org.freedesktop.DBus.Properties", 7668bd25ccdSJames Feist "GetAll", 7678bd25ccdSJames Feist "xyz.openbmc_project.Control.FanRedundancy"); 7688bd25ccdSJames Feist }, 7698bd25ccdSJames Feist "xyz.openbmc_project.ObjectMapper", path + "/inventory", 7708bd25ccdSJames Feist "org.freedesktop.DBus.Properties", "Get", 7718bd25ccdSJames Feist "xyz.openbmc_project.Association", "endpoints"); 7728bd25ccdSJames Feist } 7738bd25ccdSJames Feist }, 7748bd25ccdSJames Feist "xyz.openbmc_project.ObjectMapper", 7758bd25ccdSJames Feist "/xyz/openbmc_project/object_mapper", 7768bd25ccdSJames Feist "xyz.openbmc_project.ObjectMapper", "GetSubTree", 7778bd25ccdSJames Feist "/xyz/openbmc_project/control", 2, 7788bd25ccdSJames Feist std::array<const char*, 1>{ 7798bd25ccdSJames Feist "xyz.openbmc_project.Control.FanRedundancy"}); 7808bd25ccdSJames Feist } 7818bd25ccdSJames Feist 78249c53ac9SJohnathan Mantey void sortJSONResponse(std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp) 78349c53ac9SJohnathan Mantey { 78449c53ac9SJohnathan Mantey nlohmann::json& response = SensorsAsyncResp->res.jsonValue; 78549c53ac9SJohnathan Mantey std::array<std::string, 2> sensorHeaders{"Temperatures", "Fans"}; 78649c53ac9SJohnathan Mantey if (SensorsAsyncResp->chassisSubNode == "Power") 78749c53ac9SJohnathan Mantey { 78849c53ac9SJohnathan Mantey sensorHeaders = {"Voltages", "PowerSupplies"}; 78949c53ac9SJohnathan Mantey } 79049c53ac9SJohnathan Mantey for (const std::string& sensorGroup : sensorHeaders) 79149c53ac9SJohnathan Mantey { 79249c53ac9SJohnathan Mantey nlohmann::json::iterator entry = response.find(sensorGroup); 79349c53ac9SJohnathan Mantey if (entry != response.end()) 79449c53ac9SJohnathan Mantey { 79549c53ac9SJohnathan Mantey std::sort(entry->begin(), entry->end(), 79649c53ac9SJohnathan Mantey [](nlohmann::json& c1, nlohmann::json& c2) { 79749c53ac9SJohnathan Mantey return c1["Name"] < c2["Name"]; 79849c53ac9SJohnathan Mantey }); 79949c53ac9SJohnathan Mantey 80049c53ac9SJohnathan Mantey // add the index counts to the end of each entry 80149c53ac9SJohnathan Mantey size_t count = 0; 80249c53ac9SJohnathan Mantey for (nlohmann::json& sensorJson : *entry) 80349c53ac9SJohnathan Mantey { 80449c53ac9SJohnathan Mantey nlohmann::json::iterator odata = sensorJson.find("@odata.id"); 80549c53ac9SJohnathan Mantey if (odata == sensorJson.end()) 80649c53ac9SJohnathan Mantey { 80749c53ac9SJohnathan Mantey continue; 80849c53ac9SJohnathan Mantey } 80949c53ac9SJohnathan Mantey std::string* value = odata->get_ptr<std::string*>(); 81049c53ac9SJohnathan Mantey if (value != nullptr) 81149c53ac9SJohnathan Mantey { 81249c53ac9SJohnathan Mantey *value += std::to_string(count); 81349c53ac9SJohnathan Mantey count++; 81449c53ac9SJohnathan Mantey } 81549c53ac9SJohnathan Mantey } 81649c53ac9SJohnathan Mantey } 81749c53ac9SJohnathan Mantey } 81849c53ac9SJohnathan Mantey } 81949c53ac9SJohnathan Mantey 82008777fb0SLewanczyk, Dawid /** 821de629b6eSShawn McCarney * @brief Gets the values of the specified sensors. 822de629b6eSShawn McCarney * 823de629b6eSShawn McCarney * Stores the results as JSON in the SensorsAsyncResp. 824de629b6eSShawn McCarney * 825de629b6eSShawn McCarney * Gets the sensor values asynchronously. Stores the results later when the 826de629b6eSShawn McCarney * information has been obtained. 827de629b6eSShawn McCarney * 828de629b6eSShawn McCarney * The sensorNames set contains all sensors for the current chassis. 829de629b6eSShawn McCarney * SensorsAsyncResp contains the requested sensor types. Only sensors of a 830de629b6eSShawn McCarney * requested type are included in the JSON output. 831de629b6eSShawn McCarney * 832de629b6eSShawn McCarney * To minimize the number of DBus calls, the DBus method 833de629b6eSShawn McCarney * org.freedesktop.DBus.ObjectManager.GetManagedObjects() is used to get the 834de629b6eSShawn McCarney * values of all sensors provided by a connection (service). 835de629b6eSShawn McCarney * 836de629b6eSShawn McCarney * The connections set contains all the connections that provide sensor values. 837de629b6eSShawn McCarney * 838de629b6eSShawn McCarney * The objectMgrPaths map contains mappings from a connection name to the 839de629b6eSShawn McCarney * corresponding DBus object path that implements ObjectManager. 840de629b6eSShawn McCarney * 841de629b6eSShawn McCarney * @param SensorsAsyncResp Pointer to object holding response data. 842de629b6eSShawn McCarney * @param sensorNames All sensors within the current chassis. 843de629b6eSShawn McCarney * @param connections Connections that provide sensor values. 844de629b6eSShawn McCarney * @param objectMgrPaths Mappings from connection name to DBus object path that 845de629b6eSShawn McCarney * implements ObjectManager. 846de629b6eSShawn McCarney */ 847de629b6eSShawn McCarney void getSensorData( 848de629b6eSShawn McCarney std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp, 84949c53ac9SJohnathan Mantey const std::shared_ptr<boost::container::flat_set<std::string>> sensorNames, 850de629b6eSShawn McCarney const boost::container::flat_set<std::string>& connections, 851de629b6eSShawn McCarney const boost::container::flat_map<std::string, std::string>& objectMgrPaths) 852de629b6eSShawn McCarney { 853de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getSensorData enter"; 854de629b6eSShawn McCarney // Get managed objects from all services exposing sensors 855de629b6eSShawn McCarney for (const std::string& connection : connections) 856de629b6eSShawn McCarney { 857de629b6eSShawn McCarney // Response handler to process managed objects 85849c53ac9SJohnathan Mantey auto getManagedObjectsCb = [SensorsAsyncResp, sensorNames]( 859de629b6eSShawn McCarney const boost::system::error_code ec, 860de629b6eSShawn McCarney ManagedObjectsVectorType& resp) { 861de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getManagedObjectsCb enter"; 862de629b6eSShawn McCarney if (ec) 863de629b6eSShawn McCarney { 864de629b6eSShawn McCarney BMCWEB_LOG_ERROR << "getManagedObjectsCb DBUS error: " << ec; 865de629b6eSShawn McCarney messages::internalError(SensorsAsyncResp->res); 866de629b6eSShawn McCarney return; 867de629b6eSShawn McCarney } 868de629b6eSShawn McCarney // Go through all objects and update response with sensor data 869de629b6eSShawn McCarney for (const auto& objDictEntry : resp) 870de629b6eSShawn McCarney { 871de629b6eSShawn McCarney const std::string& objPath = 872de629b6eSShawn McCarney static_cast<const std::string&>(objDictEntry.first); 873de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getManagedObjectsCb parsing object " 874de629b6eSShawn McCarney << objPath; 875de629b6eSShawn McCarney 876de629b6eSShawn McCarney std::vector<std::string> split; 877de629b6eSShawn McCarney // Reserve space for 878de629b6eSShawn McCarney // /xyz/openbmc_project/sensors/<name>/<subname> 879de629b6eSShawn McCarney split.reserve(6); 880de629b6eSShawn McCarney boost::algorithm::split(split, objPath, boost::is_any_of("/")); 881de629b6eSShawn McCarney if (split.size() < 6) 882de629b6eSShawn McCarney { 883de629b6eSShawn McCarney BMCWEB_LOG_ERROR << "Got path that isn't long enough " 884de629b6eSShawn McCarney << objPath; 885de629b6eSShawn McCarney continue; 886de629b6eSShawn McCarney } 887de629b6eSShawn McCarney // These indexes aren't intuitive, as boost::split puts an empty 888de629b6eSShawn McCarney // string at the beginning 889de629b6eSShawn McCarney const std::string& sensorType = split[4]; 890de629b6eSShawn McCarney const std::string& sensorName = split[5]; 891de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "sensorName " << sensorName 892de629b6eSShawn McCarney << " sensorType " << sensorType; 89349c53ac9SJohnathan Mantey if (sensorNames->find(objPath) == sensorNames->end()) 894de629b6eSShawn McCarney { 895de629b6eSShawn McCarney BMCWEB_LOG_ERROR << sensorName << " not in sensor list "; 896de629b6eSShawn McCarney continue; 897de629b6eSShawn McCarney } 898de629b6eSShawn McCarney 899de629b6eSShawn McCarney const char* fieldName = nullptr; 900de629b6eSShawn McCarney if (sensorType == "temperature") 901de629b6eSShawn McCarney { 902de629b6eSShawn McCarney fieldName = "Temperatures"; 903de629b6eSShawn McCarney } 904de629b6eSShawn McCarney else if (sensorType == "fan" || sensorType == "fan_tach" || 905de629b6eSShawn McCarney sensorType == "fan_pwm") 906de629b6eSShawn McCarney { 907de629b6eSShawn McCarney fieldName = "Fans"; 908de629b6eSShawn McCarney } 909de629b6eSShawn McCarney else if (sensorType == "voltage") 910de629b6eSShawn McCarney { 911de629b6eSShawn McCarney fieldName = "Voltages"; 912de629b6eSShawn McCarney } 913de629b6eSShawn McCarney else if (sensorType == "current") 914de629b6eSShawn McCarney { 915de629b6eSShawn McCarney fieldName = "PowerSupplies"; 916de629b6eSShawn McCarney } 917de629b6eSShawn McCarney else if (sensorType == "power") 918de629b6eSShawn McCarney { 919de629b6eSShawn McCarney fieldName = "PowerSupplies"; 920de629b6eSShawn McCarney } 921de629b6eSShawn McCarney else 922de629b6eSShawn McCarney { 923de629b6eSShawn McCarney BMCWEB_LOG_ERROR << "Unsure how to handle sensorType " 924de629b6eSShawn McCarney << sensorType; 925de629b6eSShawn McCarney continue; 926de629b6eSShawn McCarney } 927de629b6eSShawn McCarney 928de629b6eSShawn McCarney nlohmann::json& tempArray = 929de629b6eSShawn McCarney SensorsAsyncResp->res.jsonValue[fieldName]; 930de629b6eSShawn McCarney 93149c53ac9SJohnathan Mantey if (fieldName == "PowerSupplies" && !tempArray.empty()) 93249c53ac9SJohnathan Mantey { 93349c53ac9SJohnathan Mantey // Power supplies put multiple "sensors" into a single power 93449c53ac9SJohnathan Mantey // supply entry, so only create the first one 93549c53ac9SJohnathan Mantey } 93649c53ac9SJohnathan Mantey else 93749c53ac9SJohnathan Mantey { 938de629b6eSShawn McCarney tempArray.push_back( 93949c53ac9SJohnathan Mantey {{"@odata.id", "/redfish/v1/Chassis/" + 94049c53ac9SJohnathan Mantey SensorsAsyncResp->chassisId + "/" + 94149c53ac9SJohnathan Mantey SensorsAsyncResp->chassisSubNode + 94249c53ac9SJohnathan Mantey "#/" + fieldName + "/"}}); 94349c53ac9SJohnathan Mantey } 944de629b6eSShawn McCarney nlohmann::json& sensorJson = tempArray.back(); 945de629b6eSShawn McCarney 946de629b6eSShawn McCarney objectInterfacesToJson(sensorName, sensorType, 947de629b6eSShawn McCarney objDictEntry.second, sensorJson); 948de629b6eSShawn McCarney } 94949c53ac9SJohnathan Mantey if (SensorsAsyncResp.use_count() == 1) 95049c53ac9SJohnathan Mantey { 95149c53ac9SJohnathan Mantey sortJSONResponse(SensorsAsyncResp); 95249c53ac9SJohnathan Mantey if (SensorsAsyncResp->chassisSubNode == "Thermal") 9538bd25ccdSJames Feist { 9548bd25ccdSJames Feist populateFanRedundancy(SensorsAsyncResp); 9558bd25ccdSJames Feist } 95649c53ac9SJohnathan Mantey } 957de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getManagedObjectsCb exit"; 958de629b6eSShawn McCarney }; 959de629b6eSShawn McCarney 960de629b6eSShawn McCarney // Find DBus object path that implements ObjectManager for the current 961de629b6eSShawn McCarney // connection. If no mapping found, default to "/". 962de629b6eSShawn McCarney auto iter = objectMgrPaths.find(connection); 963de629b6eSShawn McCarney const std::string& objectMgrPath = 964de629b6eSShawn McCarney (iter != objectMgrPaths.end()) ? iter->second : "/"; 965de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "ObjectManager path for " << connection << " is " 966de629b6eSShawn McCarney << objectMgrPath; 967de629b6eSShawn McCarney 968de629b6eSShawn McCarney crow::connections::systemBus->async_method_call( 969de629b6eSShawn McCarney getManagedObjectsCb, connection, objectMgrPath, 970de629b6eSShawn McCarney "org.freedesktop.DBus.ObjectManager", "GetManagedObjects"); 971de629b6eSShawn McCarney }; 972de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getSensorData exit"; 973de629b6eSShawn McCarney } 974de629b6eSShawn McCarney 975de629b6eSShawn McCarney /** 97608777fb0SLewanczyk, Dawid * @brief Entry point for retrieving sensors data related to requested 97708777fb0SLewanczyk, Dawid * chassis. 978588c3f0dSKowalski, Kamil * @param SensorsAsyncResp Pointer to object holding response data 97908777fb0SLewanczyk, Dawid */ 9801abe55efSEd Tanous void getChassisData(std::shared_ptr<SensorsAsyncResp> SensorsAsyncResp) 9811abe55efSEd Tanous { 98255c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "getChassisData enter"; 98349c53ac9SJohnathan Mantey auto getChassisCb = 98449c53ac9SJohnathan Mantey [SensorsAsyncResp]( 98549c53ac9SJohnathan Mantey std::shared_ptr<boost::container::flat_set<std::string>> 98608777fb0SLewanczyk, Dawid sensorNames) { 98755c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "getChassisCb enter"; 988588c3f0dSKowalski, Kamil auto getConnectionCb = 98949c53ac9SJohnathan Mantey [SensorsAsyncResp, 99049c53ac9SJohnathan Mantey sensorNames](const boost::container::flat_set<std::string>& 99149c53ac9SJohnathan Mantey connections) { 99255c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "getConnectionCb enter"; 993de629b6eSShawn McCarney auto getObjectManagerPathsCb = 99449c53ac9SJohnathan Mantey [SensorsAsyncResp, sensorNames, connections]( 99549c53ac9SJohnathan Mantey const boost::container::flat_map< 996de629b6eSShawn McCarney std::string, std::string>& objectMgrPaths) { 997de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getObjectManagerPathsCb enter"; 99849c53ac9SJohnathan Mantey // Get sensor data and store results in JSON 99949c53ac9SJohnathan Mantey // response 1000de629b6eSShawn McCarney getSensorData(SensorsAsyncResp, sensorNames, 1001de629b6eSShawn McCarney connections, objectMgrPaths); 1002de629b6eSShawn McCarney BMCWEB_LOG_DEBUG << "getObjectManagerPathsCb exit"; 100308777fb0SLewanczyk, Dawid }; 1004de629b6eSShawn McCarney 100549c53ac9SJohnathan Mantey // Get mapping from connection names to the DBus object 100649c53ac9SJohnathan Mantey // paths that implement the ObjectManager interface 1007de629b6eSShawn McCarney getObjectManagerPaths(SensorsAsyncResp, 1008de629b6eSShawn McCarney std::move(getObjectManagerPathsCb)); 100955c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "getConnectionCb exit"; 101008777fb0SLewanczyk, Dawid }; 1011de629b6eSShawn McCarney 1012de629b6eSShawn McCarney // Get set of connections that provide sensor values 10131abe55efSEd Tanous getConnections(SensorsAsyncResp, sensorNames, 10141abe55efSEd Tanous std::move(getConnectionCb)); 101555c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "getChassisCb exit"; 101608777fb0SLewanczyk, Dawid }; 101708777fb0SLewanczyk, Dawid 1018*26f03899SShawn McCarney // Get set of sensors in chassis 1019588c3f0dSKowalski, Kamil getChassis(SensorsAsyncResp, std::move(getChassisCb)); 102055c7b7a2SEd Tanous BMCWEB_LOG_DEBUG << "getChassisData exit"; 102108777fb0SLewanczyk, Dawid }; 102208777fb0SLewanczyk, Dawid 1023413961deSRichard Marian Thomaiyar /** 102449c53ac9SJohnathan Mantey * @brief Find the requested sensorName in the list of all sensors supplied by 102549c53ac9SJohnathan Mantey * the chassis node 102649c53ac9SJohnathan Mantey * 102749c53ac9SJohnathan Mantey * @param sensorName The sensor name supplied in the PATCH request 102849c53ac9SJohnathan Mantey * @param sensorsList The list of sensors managed by the chassis node 102949c53ac9SJohnathan Mantey * @param sensorsModified The list of sensors that were found as a result of 103049c53ac9SJohnathan Mantey * repeated calls to this function 103149c53ac9SJohnathan Mantey */ 103249c53ac9SJohnathan Mantey bool findSensorNameUsingSensorPath( 103349c53ac9SJohnathan Mantey const std::string& sensorName, 103449c53ac9SJohnathan Mantey boost::container::flat_set<std::string>& sensorsList, 103549c53ac9SJohnathan Mantey boost::container::flat_set<std::string>& sensorsModified) 103649c53ac9SJohnathan Mantey { 103749c53ac9SJohnathan Mantey for (const std::string& chassisSensor : sensorsList) 103849c53ac9SJohnathan Mantey { 103949c53ac9SJohnathan Mantey std::string thisSensorName; 104049c53ac9SJohnathan Mantey if (!dbus::utility::getNthStringFromPath(chassisSensor, 5, 104149c53ac9SJohnathan Mantey thisSensorName)) 104249c53ac9SJohnathan Mantey { 104349c53ac9SJohnathan Mantey BMCWEB_LOG_ERROR << "Got path that isn't long enough " 104449c53ac9SJohnathan Mantey << chassisSensor; 104549c53ac9SJohnathan Mantey continue; 104649c53ac9SJohnathan Mantey } 104749c53ac9SJohnathan Mantey if (thisSensorName == sensorName) 104849c53ac9SJohnathan Mantey { 104949c53ac9SJohnathan Mantey sensorsModified.emplace(chassisSensor); 105049c53ac9SJohnathan Mantey return true; 105149c53ac9SJohnathan Mantey } 105249c53ac9SJohnathan Mantey } 105349c53ac9SJohnathan Mantey return false; 105449c53ac9SJohnathan Mantey } 105549c53ac9SJohnathan Mantey 105649c53ac9SJohnathan Mantey /** 1057413961deSRichard Marian Thomaiyar * @brief Entry point for overriding sensor values of given sensor 1058413961deSRichard Marian Thomaiyar * 1059413961deSRichard Marian Thomaiyar * @param res response object 1060413961deSRichard Marian Thomaiyar * @param req request object 1061413961deSRichard Marian Thomaiyar * @param params parameter passed for CRUD 1062413961deSRichard Marian Thomaiyar * @param typeList TypeList of sensors for the resource queried 1063413961deSRichard Marian Thomaiyar * @param chassisSubNode Chassis Node for which the query has to happen 1064413961deSRichard Marian Thomaiyar */ 1065413961deSRichard Marian Thomaiyar void setSensorOverride(crow::Response& res, const crow::Request& req, 1066413961deSRichard Marian Thomaiyar const std::vector<std::string>& params, 1067b01bf299SEd Tanous const std::initializer_list<const char*> typeList, 1068413961deSRichard Marian Thomaiyar const std::string& chassisSubNode) 1069413961deSRichard Marian Thomaiyar { 1070413961deSRichard Marian Thomaiyar 1071413961deSRichard Marian Thomaiyar // TODO: Need to figure out dynamic way to restrict patch (Set Sensor 1072413961deSRichard Marian Thomaiyar // override) based on another d-bus announcement to be more generic. 1073413961deSRichard Marian Thomaiyar if (params.size() != 1) 1074413961deSRichard Marian Thomaiyar { 1075413961deSRichard Marian Thomaiyar messages::internalError(res); 1076413961deSRichard Marian Thomaiyar res.end(); 1077413961deSRichard Marian Thomaiyar return; 1078413961deSRichard Marian Thomaiyar } 1079f65af9e8SRichard Marian Thomaiyar 1080f65af9e8SRichard Marian Thomaiyar std::unordered_map<std::string, std::vector<nlohmann::json>> allCollections; 1081f65af9e8SRichard Marian Thomaiyar std::optional<std::vector<nlohmann::json>> temperatureCollections; 1082f65af9e8SRichard Marian Thomaiyar std::optional<std::vector<nlohmann::json>> fanCollections; 1083f65af9e8SRichard Marian Thomaiyar std::vector<nlohmann::json> voltageCollections; 1084f65af9e8SRichard Marian Thomaiyar BMCWEB_LOG_INFO << "setSensorOverride for subNode" << chassisSubNode 1085f65af9e8SRichard Marian Thomaiyar << "\n"; 1086f65af9e8SRichard Marian Thomaiyar 1087413961deSRichard Marian Thomaiyar if (chassisSubNode == "Thermal") 1088413961deSRichard Marian Thomaiyar { 1089f65af9e8SRichard Marian Thomaiyar if (!json_util::readJson(req, res, "Temperatures", 1090f65af9e8SRichard Marian Thomaiyar temperatureCollections, "Fans", 1091f65af9e8SRichard Marian Thomaiyar fanCollections)) 1092f65af9e8SRichard Marian Thomaiyar { 1093f65af9e8SRichard Marian Thomaiyar return; 1094f65af9e8SRichard Marian Thomaiyar } 1095f65af9e8SRichard Marian Thomaiyar if (!temperatureCollections && !fanCollections) 1096f65af9e8SRichard Marian Thomaiyar { 1097f65af9e8SRichard Marian Thomaiyar messages::resourceNotFound(res, "Thermal", 1098f65af9e8SRichard Marian Thomaiyar "Temperatures / Voltages"); 1099f65af9e8SRichard Marian Thomaiyar res.end(); 1100f65af9e8SRichard Marian Thomaiyar return; 1101f65af9e8SRichard Marian Thomaiyar } 1102f65af9e8SRichard Marian Thomaiyar if (temperatureCollections) 1103f65af9e8SRichard Marian Thomaiyar { 1104f65af9e8SRichard Marian Thomaiyar allCollections.emplace("Temperatures", 1105f65af9e8SRichard Marian Thomaiyar *std::move(temperatureCollections)); 1106f65af9e8SRichard Marian Thomaiyar } 1107f65af9e8SRichard Marian Thomaiyar if (fanCollections) 1108f65af9e8SRichard Marian Thomaiyar { 1109f65af9e8SRichard Marian Thomaiyar allCollections.emplace("Fans", *std::move(fanCollections)); 1110f65af9e8SRichard Marian Thomaiyar } 1111413961deSRichard Marian Thomaiyar } 1112413961deSRichard Marian Thomaiyar else if (chassisSubNode == "Power") 1113413961deSRichard Marian Thomaiyar { 1114f65af9e8SRichard Marian Thomaiyar if (!json_util::readJson(req, res, "Voltages", voltageCollections)) 1115f65af9e8SRichard Marian Thomaiyar { 1116f65af9e8SRichard Marian Thomaiyar return; 1117f65af9e8SRichard Marian Thomaiyar } 1118f65af9e8SRichard Marian Thomaiyar allCollections.emplace("Voltages", std::move(voltageCollections)); 1119413961deSRichard Marian Thomaiyar } 1120413961deSRichard Marian Thomaiyar else 1121413961deSRichard Marian Thomaiyar { 1122413961deSRichard Marian Thomaiyar res.result(boost::beast::http::status::not_found); 1123413961deSRichard Marian Thomaiyar res.end(); 1124413961deSRichard Marian Thomaiyar return; 1125413961deSRichard Marian Thomaiyar } 1126413961deSRichard Marian Thomaiyar 1127f65af9e8SRichard Marian Thomaiyar const char* propertyValueName; 1128f65af9e8SRichard Marian Thomaiyar std::unordered_map<std::string, std::pair<double, std::string>> overrideMap; 1129413961deSRichard Marian Thomaiyar std::string memberId; 1130413961deSRichard Marian Thomaiyar double value; 1131f65af9e8SRichard Marian Thomaiyar for (auto& collectionItems : allCollections) 1132f65af9e8SRichard Marian Thomaiyar { 1133f65af9e8SRichard Marian Thomaiyar if (collectionItems.first == "Temperatures") 1134f65af9e8SRichard Marian Thomaiyar { 1135f65af9e8SRichard Marian Thomaiyar propertyValueName = "ReadingCelsius"; 1136f65af9e8SRichard Marian Thomaiyar } 1137f65af9e8SRichard Marian Thomaiyar else if (collectionItems.first == "Fans") 1138f65af9e8SRichard Marian Thomaiyar { 1139f65af9e8SRichard Marian Thomaiyar propertyValueName = "Reading"; 1140f65af9e8SRichard Marian Thomaiyar } 1141f65af9e8SRichard Marian Thomaiyar else 1142f65af9e8SRichard Marian Thomaiyar { 1143f65af9e8SRichard Marian Thomaiyar propertyValueName = "ReadingVolts"; 1144f65af9e8SRichard Marian Thomaiyar } 1145f65af9e8SRichard Marian Thomaiyar for (auto& item : collectionItems.second) 1146f65af9e8SRichard Marian Thomaiyar { 1147f65af9e8SRichard Marian Thomaiyar if (!json_util::readJson(item, res, "MemberId", memberId, 1148413961deSRichard Marian Thomaiyar propertyValueName, value)) 1149413961deSRichard Marian Thomaiyar { 1150413961deSRichard Marian Thomaiyar return; 1151413961deSRichard Marian Thomaiyar } 1152f65af9e8SRichard Marian Thomaiyar overrideMap.emplace(memberId, 1153f65af9e8SRichard Marian Thomaiyar std::make_pair(value, collectionItems.first)); 1154f65af9e8SRichard Marian Thomaiyar } 1155f65af9e8SRichard Marian Thomaiyar } 1156413961deSRichard Marian Thomaiyar const std::string& chassisName = params[0]; 1157413961deSRichard Marian Thomaiyar auto sensorAsyncResp = std::make_shared<SensorsAsyncResp>( 1158413961deSRichard Marian Thomaiyar res, chassisName, typeList, chassisSubNode); 115949c53ac9SJohnathan Mantey auto getChassisSensorListCb = [sensorAsyncResp, 116049c53ac9SJohnathan Mantey overrideMap](const std::shared_ptr< 116149c53ac9SJohnathan Mantey boost::container::flat_set< 116249c53ac9SJohnathan Mantey std::string>> 116349c53ac9SJohnathan Mantey sensorsList) { 116449c53ac9SJohnathan Mantey // Match sensor names in the PATCH request to those managed by the 116549c53ac9SJohnathan Mantey // chassis node 116649c53ac9SJohnathan Mantey const std::shared_ptr<boost::container::flat_set<std::string>> 116749c53ac9SJohnathan Mantey sensorNames = 116849c53ac9SJohnathan Mantey std::make_shared<boost::container::flat_set<std::string>>(); 1169f65af9e8SRichard Marian Thomaiyar for (const auto& item : overrideMap) 1170413961deSRichard Marian Thomaiyar { 1171f65af9e8SRichard Marian Thomaiyar const auto& sensor = item.first; 117249c53ac9SJohnathan Mantey if (!findSensorNameUsingSensorPath(sensor, *sensorsList, 117349c53ac9SJohnathan Mantey *sensorNames)) 1174f65af9e8SRichard Marian Thomaiyar { 1175f65af9e8SRichard Marian Thomaiyar BMCWEB_LOG_INFO << "Unable to find memberId " << item.first; 1176413961deSRichard Marian Thomaiyar messages::resourceNotFound(sensorAsyncResp->res, 1177f65af9e8SRichard Marian Thomaiyar item.second.second, item.first); 1178413961deSRichard Marian Thomaiyar return; 1179413961deSRichard Marian Thomaiyar } 1180f65af9e8SRichard Marian Thomaiyar } 1181413961deSRichard Marian Thomaiyar // Get the connection to which the memberId belongs 1182413961deSRichard Marian Thomaiyar auto getObjectsWithConnectionCb = 1183f65af9e8SRichard Marian Thomaiyar [sensorAsyncResp, overrideMap]( 1184413961deSRichard Marian Thomaiyar const boost::container::flat_set<std::string>& connections, 1185413961deSRichard Marian Thomaiyar const std::set<std::pair<std::string, std::string>>& 1186413961deSRichard Marian Thomaiyar objectsWithConnection) { 1187f65af9e8SRichard Marian Thomaiyar if (objectsWithConnection.size() != overrideMap.size()) 1188413961deSRichard Marian Thomaiyar { 1189413961deSRichard Marian Thomaiyar BMCWEB_LOG_INFO 1190f65af9e8SRichard Marian Thomaiyar << "Unable to find all objects with proper connection " 1191f65af9e8SRichard Marian Thomaiyar << objectsWithConnection.size() << " requested " 1192f65af9e8SRichard Marian Thomaiyar << overrideMap.size() << "\n"; 1193413961deSRichard Marian Thomaiyar messages::resourceNotFound( 1194413961deSRichard Marian Thomaiyar sensorAsyncResp->res, 1195413961deSRichard Marian Thomaiyar sensorAsyncResp->chassisSubNode == "Thermal" 1196413961deSRichard Marian Thomaiyar ? "Temperatures" 1197413961deSRichard Marian Thomaiyar : "Voltages", 1198f65af9e8SRichard Marian Thomaiyar "Count"); 1199f65af9e8SRichard Marian Thomaiyar return; 1200f65af9e8SRichard Marian Thomaiyar } 1201f65af9e8SRichard Marian Thomaiyar for (const auto& item : objectsWithConnection) 1202f65af9e8SRichard Marian Thomaiyar { 1203f65af9e8SRichard Marian Thomaiyar 1204f65af9e8SRichard Marian Thomaiyar auto lastPos = item.first.rfind('/'); 1205f65af9e8SRichard Marian Thomaiyar if (lastPos == std::string::npos) 1206f65af9e8SRichard Marian Thomaiyar { 1207f65af9e8SRichard Marian Thomaiyar messages::internalError(sensorAsyncResp->res); 1208f65af9e8SRichard Marian Thomaiyar return; 1209f65af9e8SRichard Marian Thomaiyar } 1210f65af9e8SRichard Marian Thomaiyar std::string sensorName = item.first.substr(lastPos + 1); 1211f65af9e8SRichard Marian Thomaiyar 1212f65af9e8SRichard Marian Thomaiyar const auto& iterator = overrideMap.find(sensorName); 1213f65af9e8SRichard Marian Thomaiyar if (iterator == overrideMap.end()) 1214f65af9e8SRichard Marian Thomaiyar { 1215f65af9e8SRichard Marian Thomaiyar BMCWEB_LOG_INFO << "Unable to find sensor object" 1216f65af9e8SRichard Marian Thomaiyar << item.first << "\n"; 1217f65af9e8SRichard Marian Thomaiyar messages::internalError(sensorAsyncResp->res); 1218413961deSRichard Marian Thomaiyar return; 1219413961deSRichard Marian Thomaiyar } 1220413961deSRichard Marian Thomaiyar crow::connections::systemBus->async_method_call( 1221f65af9e8SRichard Marian Thomaiyar [sensorAsyncResp](const boost::system::error_code ec) { 1222413961deSRichard Marian Thomaiyar if (ec) 1223413961deSRichard Marian Thomaiyar { 1224413961deSRichard Marian Thomaiyar BMCWEB_LOG_DEBUG 1225f65af9e8SRichard Marian Thomaiyar << "setOverrideValueStatus DBUS error: " 1226413961deSRichard Marian Thomaiyar << ec; 1227413961deSRichard Marian Thomaiyar messages::internalError(sensorAsyncResp->res); 1228413961deSRichard Marian Thomaiyar return; 1229413961deSRichard Marian Thomaiyar } 1230413961deSRichard Marian Thomaiyar }, 1231f65af9e8SRichard Marian Thomaiyar item.second, item.first, 1232413961deSRichard Marian Thomaiyar "org.freedesktop.DBus.Properties", "Set", 1233413961deSRichard Marian Thomaiyar "xyz.openbmc_project.Sensor.Value", "Value", 1234f65af9e8SRichard Marian Thomaiyar sdbusplus::message::variant<double>( 1235f65af9e8SRichard Marian Thomaiyar iterator->second.first)); 1236f65af9e8SRichard Marian Thomaiyar } 1237413961deSRichard Marian Thomaiyar }; 1238413961deSRichard Marian Thomaiyar // Get object with connection for the given sensor name 1239413961deSRichard Marian Thomaiyar getObjectsWithConnection(sensorAsyncResp, sensorNames, 1240413961deSRichard Marian Thomaiyar std::move(getObjectsWithConnectionCb)); 1241413961deSRichard Marian Thomaiyar }; 1242413961deSRichard Marian Thomaiyar // get full sensor list for the given chassisId and cross verify the sensor. 1243413961deSRichard Marian Thomaiyar getChassis(sensorAsyncResp, std::move(getChassisSensorListCb)); 1244413961deSRichard Marian Thomaiyar } 1245413961deSRichard Marian Thomaiyar 124608777fb0SLewanczyk, Dawid } // namespace redfish 1247