| #pragma once |
| |
| #include "app.hpp" |
| #include "dbus_utility.hpp" |
| #include "error_messages.hpp" |
| #include "managed_store.hpp" |
| #include "managed_store_types.hpp" |
| #include "query.hpp" |
| #include "registries/privilege_registry.hpp" |
| #include "utils/chassis_utils.hpp" |
| #include "utils/json_utils.hpp" |
| #include "utils/location_utils.hpp" |
| |
| #include <boost/system/error_code.hpp> |
| #include <boost/url/format.hpp> |
| #include <sdbusplus/asio/property.hpp> |
| #include <sdbusplus/message/types.hpp> |
| |
| #include <functional> |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <string_view> |
| |
| #ifdef UNIT_TEST_BUILD |
| #include "test/g3/mock_managed_store.hpp" // NOLINT |
| #endif |
| |
| namespace redfish |
| { |
| |
| constexpr std::array<std::string_view, 1> fanInterfaces = { |
| "xyz.openbmc_project.Configuration.Fan"}; |
| constexpr std::array<std::string_view, 1> sensorInterfaces = { |
| "xyz.openbmc_project.Sensor.Value"}; |
| |
| inline void |
| updateFanList(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId, |
| const dbus::utility::MapperGetSubTreePathsResponse& fanPaths) |
| { |
| nlohmann::json& fanList = asyncResp->res.jsonValue["Members"]; |
| for (const std::string& fanPath : fanPaths) |
| { |
| if (fanPath.empty()) |
| { |
| BMCWEB_LOG_DEBUG << "Error getting D-Bus object!"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string fanName = |
| sdbusplus::message::object_path(fanPath).filename(); |
| |
| std::string chassisName; |
| |
| // 5 below comes from |
| // /xyz/openbmc_project/inventory/system/chassis/chassisName/fanName |
| // 0 1 2 3 4 5 6 |
| if (!dbus::utility::getNthStringFromPath(fanPath, 5, chassisName) || |
| fanName.empty()) |
| { |
| BMCWEB_LOG_ERROR << "Got invalid path " << fanPath; |
| messages::invalidObject( |
| asyncResp->res, |
| crow::utility::urlFromPieces("xyz", "openbmc_project", |
| "inventory", "system", fanPath)); |
| continue; |
| } |
| |
| if (chassisName != chassisId) |
| { |
| BMCWEB_LOG_ERROR << "The fan obtained at this time " |
| "does not belong to this chassis "; |
| continue; |
| } |
| |
| nlohmann::json item = nlohmann::json::object(); |
| item["@odata.id"] = boost::urls::format( |
| "/redfish/v1/Chassis/{}/ThermalSubsystem/Fans/{}", chassisId, |
| fanName); |
| |
| fanList.emplace_back(std::move(item)); |
| } |
| asyncResp->res.jsonValue["Members@odata.count"] = fanList.size(); |
| } |
| |
| inline void getFanPaths( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::optional<std::string>& validChassisPath, |
| const std::function<void(const dbus::utility::MapperGetSubTreePathsResponse& |
| fanPaths)>& callback) |
| { |
| sdbusplus::message::object_path endpointPath{*validChassisPath}; |
| endpointPath /= "cooled_by"; |
| |
| // TODO(tomtung): enable this after setting up associations. |
| // dbus::utility::getAssociatedSubTreePaths( |
| // endpointPath, |
| // sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), 0, |
| // fanInterfaces, |
| // [asyncResp, callback]( |
| // const boost::system::error_code& ec, |
| // const dbus::utility::MapperGetSubTreePathsResponse& subtreePaths) |
| // { |
| // if (ec) |
| // { |
| // if (ec.value() != EBADR) |
| // { |
| // BMCWEB_LOG_ERROR |
| // << "DBUS response error for getAssociatedSubTreePaths " |
| // << ec.value(); |
| // messages::internalError(asyncResp->res); |
| // } |
| // return; |
| // } |
| // callback(subtreePaths); |
| // }); |
| |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getSubTreePaths( |
| "/xyz/openbmc_project/inventory", 0, fanInterfaces, context, |
| [asyncResp, callback]( |
| const boost::system::error_code& ec, |
| const dbus::utility::MapperGetSubTreePathsResponse& subtreePaths) { |
| if (ec) |
| { |
| BMCWEB_LOG_DEBUG << "DBUS response error"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| callback(subtreePaths); |
| }); |
| } |
| |
| inline void doFanCollection(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId, |
| const std::optional<std::string>& validChassisPath) |
| { |
| if (!validChassisPath) |
| { |
| BMCWEB_LOG_ERROR << "Not a valid chassis ID" << chassisId; |
| messages::resourceNotFound(asyncResp->res, "Chassis", chassisId); |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Get fan list associated to chassis = " << chassisId; |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/FanCollection/FanCollection.json>; rel=describedby"); |
| asyncResp->res.jsonValue["@odata.type"] = "#FanCollection.FanCollection"; |
| asyncResp->res.jsonValue["@odata.id"] = boost::urls::format( |
| "/redfish/v1/Chassis/{}/ThermalSubsystem/Fans", chassisId); |
| asyncResp->res.jsonValue["Name"] = "Fan Collection"; |
| asyncResp->res.jsonValue["Description"] = |
| "The collection of Fan resource instances " + chassisId; |
| asyncResp->res.jsonValue["Members"] = nlohmann::json::array(); |
| asyncResp->res.jsonValue["Members@odata.count"] = 0; |
| |
| getFanPaths(asyncResp, validChassisPath, |
| std::bind_front(updateFanList, asyncResp, chassisId)); |
| } |
| |
| inline void |
| getFanSensorValue(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId, |
| const std::string& sensorName, |
| const std::string& sensorType) |
| { |
| constexpr std::array<std::string_view, 4> supportedSensorTypes = { |
| "fan_tach", "fan_pwm", "secondary_fan_tach", "secondary_fan_pwm"}; |
| if (std::find(supportedSensorTypes.begin(), supportedSensorTypes.end(), |
| sensorType) == supportedSensorTypes.end()) |
| { |
| BMCWEB_LOG_DEBUG << "Unsupported sensor type"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| auto getFanSensorsHandler = |
| [asyncResp, chassisId, sensorName, sensorType, requestContext]( |
| const boost::system::error_code ec, |
| const std::vector<std::pair< |
| std::string, |
| std::vector<std::pair<std::string, std::vector<std::string>>>>>& |
| sensorsubtree) { |
| if (ec) |
| { |
| BMCWEB_LOG_DEBUG << "D-Bus response error on GetSubTree " << ec; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| for (const auto& [objectPath, serviceNames] : sensorsubtree) |
| { |
| if (serviceNames.size() > 1) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Skipping over ambiguous sensor served by multiple services: " |
| << objectPath; |
| continue; |
| } |
| if (objectPath.empty() || serviceNames.size() != 1) |
| { |
| BMCWEB_LOG_DEBUG << "Error getting Fan D-Bus object!"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| sdbusplus::message::object_path path(objectPath); |
| const std::string& leaf = path.filename(); |
| if (leaf.empty()) |
| { |
| continue; |
| } |
| if (leaf != sensorName) |
| { |
| continue; |
| } |
| |
| // There is no reason to populate PartLocationContext only for |
| // fan_pwm but it happens so that both fan_pwm and fan_tach |
| // sensors are associated with the same chassis through entity |
| // manager config today so we arbitraty picked fan_pwm to find |
| // the associated chassis. |
| if (sensorType == "fan_pwm") |
| { |
| // Get PartLocationContext |
| location_util::getPartLocationContext( |
| asyncResp, "/Location"_json_pointer, path.str + "/chassis"); |
| } |
| |
| const std::string& connectionName = serviceNames[0].first; |
| const std::string& tempPath = objectPath; |
| auto getAssociationHandler = |
| [asyncResp, tempPath, connectionName, chassisId, sensorName, |
| sensorType, |
| requestContext](const boost::system::error_code ec2, |
| const std::vector<std::string>& resp) { |
| BMCWEB_LOG_DEBUG << "Getting chassis association for sensor " |
| << sensorName; |
| if (ec2) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Error getting chassis association for the sensor!"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| if (resp.size() != 1) |
| { |
| BMCWEB_LOG_DEBUG |
| << "The number of associated chassis should be 1"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| sdbusplus::message::object_path path2(resp[0]); |
| std::string leaf2 = path2.filename(); |
| if (leaf2 != chassisId) |
| { |
| BMCWEB_LOG_DEBUG |
| << "The sensor doesn't belong to the chassis " |
| << chassisId; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| auto getFanPropertyHandler = |
| [asyncResp, chassisId, sensorName, |
| sensorType](const boost::system::error_code ec3, |
| const double& resp2) { |
| if (ec3) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Error getting sensor value for sensor:" |
| << sensorName; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| if (sensorType == "fan_pwm" || |
| sensorType == "secondary_fan_pwm") |
| { |
| const std::string jsonKey = |
| (sensorType == "fan_pwm") ? "SpeedPercent" |
| : "SecondarySpeedPercent"; |
| asyncResp->res.jsonValue[jsonKey]["DataSourceUri"] = |
| std::string("/redfish/v1/Chassis/") |
| .append(chassisId) |
| .append("/Sensors/") |
| .append("fanpwm_" + sensorName) |
| .append("/"); |
| asyncResp->res.jsonValue[jsonKey]["Reading"] = resp2; |
| } |
| else if (sensorType == "fan_tach") |
| { |
| asyncResp->res.jsonValue["SpeedPercent"]["SpeedRPM"] = |
| resp2; |
| } |
| else if (sensorType == "secondary_fan_tach") |
| { |
| asyncResp->res |
| .jsonValue["SecondarySpeedPercent"]["SpeedRPM"] = |
| resp2; |
| } |
| }; |
| dbus_utils::getProperty<double>( |
| connectionName, tempPath, |
| "xyz.openbmc_project.Sensor.Value", "Value", requestContext, |
| getFanPropertyHandler); |
| }; |
| dbus_utils::getProperty<std::vector<std::string>>( |
| "xyz.openbmc_project.ObjectMapper", tempPath + "/chassis", |
| "xyz.openbmc_project.Association", "endpoints", requestContext, |
| getAssociationHandler); |
| } |
| }; |
| managedStore::GetManagedObjectStore()->getSubTree( |
| "/xyz/openbmc_project/sensors", 0, sensorInterfaces, requestContext, |
| getFanSensorsHandler); |
| } |
| |
| inline void |
| fillFanProperties(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const boost::system::error_code ec, |
| const dbus::utility::DBusPropertiesMap& properties, |
| const std::string& chassisId) |
| { |
| if (ec) |
| { |
| BMCWEB_LOG_DEBUG << "DBUS response error " << ec; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| for (const auto& [propKey, propVariant] : properties) |
| { |
| if (propKey == "HotPluggable") |
| { |
| const bool* hotPluggable = std::get_if<bool>(&propVariant); |
| if (hotPluggable == nullptr) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| asyncResp->res.jsonValue["HotPluggable"] = *hotPluggable; |
| } |
| else if (propKey == "LocationType") |
| { |
| const std::string* locationType = |
| std::get_if<std::string>(&propVariant); |
| if (locationType == nullptr) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| asyncResp->res |
| .jsonValue["Location"]["PartLocation"]["LocationType"] = |
| *locationType; |
| } |
| else if (propKey == "ServiceLabel") |
| { |
| const std::string* serviceLabel = |
| std::get_if<std::string>(&propVariant); |
| if (serviceLabel == nullptr) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| asyncResp->res |
| .jsonValue["Location"]["PartLocation"]["ServiceLabel"] = |
| *serviceLabel; |
| } |
| else if (propKey == "TachSensor") |
| { |
| const std::string* tachSensor = |
| std::get_if<std::string>(&propVariant); |
| if (tachSensor == nullptr) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| getFanSensorValue(asyncResp, chassisId, *tachSensor, "fan_tach"); |
| } |
| else if (propKey == "PWMSensor") |
| { |
| const std::string* pwmSensor = |
| std::get_if<std::string>(&propVariant); |
| if (pwmSensor == nullptr) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| getFanSensorValue(asyncResp, chassisId, *pwmSensor, "fan_pwm"); |
| } |
| else if (propKey == "SecondaryTachSensor") |
| { |
| const std::string* tachSensor = |
| std::get_if<std::string>(&propVariant); |
| if (tachSensor == nullptr) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| getFanSensorValue(asyncResp, chassisId, *tachSensor, |
| "secondary_fan_tach"); |
| } |
| else if (propKey == "SecondaryPWMSensor") |
| { |
| const std::string* pwmSensor = |
| std::get_if<std::string>(&propVariant); |
| if (pwmSensor == nullptr) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| getFanSensorValue(asyncResp, chassisId, *pwmSensor, |
| "secondary_fan_pwm"); |
| } |
| } |
| } |
| |
| inline void |
| addFanProperties(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& fanObjectPath, |
| const std::string& service, const std::string& chassisId) |
| { |
| BMCWEB_LOG_DEBUG << "Get Properties for Fan " << fanObjectPath; |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getAllProperties( |
| service, fanObjectPath, "xyz.openbmc_project.Configuration.Fan", |
| context, |
| [asyncResp, |
| chassisId](const boost::system::error_code ec, |
| const dbus::utility::DBusPropertiesMap& properties) { |
| fillFanProperties(asyncResp, ec, properties, chassisId); |
| }); |
| } |
| |
| inline void |
| handleFanCollectionHead(App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| |
| redfish::chassis_utils::getValidChassisPath( |
| asyncResp, chassisId, |
| [asyncResp, |
| chassisId](const std::optional<std::string>& validChassisPath) { |
| if (!validChassisPath) |
| { |
| messages::resourceNotFound(asyncResp->res, "Chassis", chassisId); |
| return; |
| } |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/FanCollection/FanCollection.json>; rel=describedby"); |
| }); |
| } |
| |
| inline void |
| handleFanCollectionGet(App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| |
| redfish::chassis_utils::getValidChassisPath( |
| asyncResp, chassisId, |
| std::bind_front(doFanCollection, asyncResp, chassisId)); |
| } |
| |
| inline void requestRoutesFanCollection(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ThermalSubsystem/Fans/") |
| .privileges(redfish::privileges::headFanCollection) |
| .methods(boost::beast::http::verb::head)( |
| std::bind_front(handleFanCollectionHead, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ThermalSubsystem/Fans/") |
| .privileges(redfish::privileges::getFanCollection) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleFanCollectionGet, std::ref(app))); |
| } |
| |
| inline bool checkChassisId(const std::string& fanPath, |
| const std::string& chassisId) |
| { |
| return fanPath.find("/" + chassisId + "/") != std::string::npos; |
| } |
| |
| inline bool checkFanId(const std::string& fanPath, const std::string& fanId) |
| { |
| std::string fanName = sdbusplus::message::object_path(fanPath).filename(); |
| |
| return !(fanName.empty() || fanName != fanId); |
| } |
| |
| static inline void handleFanPath( |
| const std::string& chassisId, const std::string& fanId, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const dbus::utility::MapperGetSubTreePathsResponse& fanPaths, |
| const std::function<void(const std::string& fanPath, |
| const std::string& service)>& callback) |
| { |
| for (const auto& fanPath : fanPaths) |
| { |
| if (!checkChassisId(fanPath, chassisId) || !checkFanId(fanPath, fanId)) |
| { |
| continue; |
| } |
| |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getDbusObject( |
| fanPath, fanInterfaces, context, |
| [fanPath, asyncResp, |
| callback](const boost::system::error_code& ec, |
| const dbus::utility::MapperGetObject& object) { |
| if (ec || object.empty()) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error on getDbusObject " |
| << ec.value(); |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| callback(fanPath, object.begin()->first); |
| }); |
| |
| return; |
| } |
| BMCWEB_LOG_WARNING << "Fan not found " << fanId; |
| messages::resourceNotFound(asyncResp->res, "Fan", fanId); |
| } |
| |
| inline void getValidFanPath( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& validChassisPath, const std::string& chassisId, |
| const std::string& fanId, |
| const std::function<void(const std::string& fanPath, |
| const std::string& service)>& callback) |
| { |
| getFanPaths( |
| asyncResp, validChassisPath, |
| [chassisId, fanId, asyncResp, callback]( |
| const dbus::utility::MapperGetSubTreePathsResponse& fanPaths) { |
| handleFanPath(chassisId, fanId, asyncResp, fanPaths, callback); |
| }); |
| } |
| |
| inline void addFanCommonProperties(crow::Response& resp, |
| const std::string& chassisId, |
| const std::string& fanId) |
| { |
| resp.addHeader(boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/Fan/Fan.json>; rel=describedby"); |
| resp.jsonValue["@odata.type"] = "#Fan.v1_3_0.Fan"; |
| resp.jsonValue["Name"] = fanId; |
| resp.jsonValue["Id"] = fanId; |
| resp.jsonValue["@odata.id"] = boost::urls::format( |
| "/redfish/v1/Chassis/{}/ThermalSubsystem/Fans/{}", chassisId, fanId); |
| resp.jsonValue["Status"]["State"] = "Enabled"; |
| resp.jsonValue["Status"]["Health"] = "OK"; |
| } |
| |
| inline void getFanHealth(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& fanPath, const std::string& service) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<bool>( |
| service, fanPath, |
| "xyz.openbmc_project.State.Decorator.OperationalStatus", "Functional", |
| context, |
| [asyncResp](const boost::system::error_code& ec, const bool value) { |
| if (ec) |
| { |
| if (ec.value() != EBADR) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error for Health " |
| << ec.value(); |
| messages::internalError(asyncResp->res); |
| } |
| return; |
| } |
| |
| if (!value) |
| { |
| asyncResp->res.jsonValue["Status"]["Health"] = "Critical"; |
| } |
| }); |
| } |
| |
| inline void getFanState(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& fanPath, const std::string& service) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty<bool>( |
| service, fanPath, "xyz.openbmc_project.Inventory.Item", "Present", |
| context, |
| [asyncResp](const boost::system::error_code& ec, const bool value) { |
| if (ec) |
| { |
| if (ec.value() != EBADR) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error for State " |
| << ec.value(); |
| messages::internalError(asyncResp->res); |
| } |
| return; |
| } |
| |
| if (!value) |
| { |
| asyncResp->res.jsonValue["Status"]["State"] = "Absent"; |
| } |
| }); |
| } |
| |
| inline void getFanAsset(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& fanPath, const std::string& service) |
| { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getAllProperties( |
| service, fanPath, "xyz.openbmc_project.Inventory.Decorator.Asset", |
| context, |
| [fanPath, asyncResp{asyncResp}]( |
| const boost::system::error_code& ec, |
| const dbus::utility::DBusPropertiesMap& assetList) { |
| if (ec) |
| { |
| if (ec.value() != EBADR) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error for Properties" |
| << ec.value(); |
| messages::internalError(asyncResp->res); |
| } |
| return; |
| } |
| const std::string* manufacturer = nullptr; |
| const std::string* model = nullptr; |
| const std::string* partNumber = nullptr; |
| const std::string* serialNumber = nullptr; |
| const std::string* sparePartNumber = nullptr; |
| |
| const bool success = sdbusplus::unpackPropertiesNoThrow( |
| dbus_utils::UnpackErrorPrinter(), assetList, "Manufacturer", |
| manufacturer, "Model", model, "PartNumber", partNumber, |
| "SerialNumber", serialNumber, "SparePartNumber", sparePartNumber); |
| if (!success) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| if (manufacturer != nullptr) |
| { |
| asyncResp->res.jsonValue["Manufacturer"] = *manufacturer; |
| } |
| if (model != nullptr) |
| { |
| asyncResp->res.jsonValue["Model"] = *model; |
| } |
| if (partNumber != nullptr) |
| { |
| asyncResp->res.jsonValue["PartNumber"] = *partNumber; |
| } |
| if (serialNumber != nullptr) |
| { |
| asyncResp->res.jsonValue["SerialNumber"] = *serialNumber; |
| } |
| if (sparePartNumber != nullptr && !sparePartNumber->empty()) |
| { |
| asyncResp->res.jsonValue["SparePartNumber"] = *sparePartNumber; |
| } |
| }); |
| } |
| |
| inline void getFanLocation(const std::shared_ptr<bmcweb::AsyncResp>& aResp, |
| const std::string& fanPath, |
| const std::string& service) |
| { |
| managedStore::ManagedObjectStoreContext context(aResp); |
| dbus_utils::getProperty<std::string>( |
| service, fanPath, |
| "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode", |
| context, |
| [aResp](const boost::system::error_code& ec, |
| const std::string& property) { |
| if (ec) |
| { |
| if (ec.value() != EBADR) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error for Location" |
| << ec.value(); |
| messages::internalError(aResp->res); |
| } |
| return; |
| } |
| aResp->res.jsonValue["Location"]["PartLocation"]["ServiceLabel"] = |
| property; |
| }); |
| } |
| |
| inline void |
| afterGetValidFanPath(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId, const std::string& fanId, |
| const std::string& fanPath, const std::string& service) |
| { |
| addFanCommonProperties(asyncResp->res, chassisId, fanId); |
| getFanState(asyncResp, fanPath, service); |
| getFanHealth(asyncResp, fanPath, service); |
| getFanAsset(asyncResp, fanPath, service); |
| getFanLocation(asyncResp, fanPath, service); |
| addFanProperties(asyncResp, fanPath, service, chassisId); |
| } |
| |
| inline void doFanGet(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId, const std::string& fanId, |
| const std::optional<std::string>& validChassisPath) |
| { |
| if (!validChassisPath) |
| { |
| BMCWEB_LOG_ERROR << "Not a valid chassis ID" << chassisId; |
| messages::resourceNotFound(asyncResp->res, "Chassis", chassisId); |
| return; |
| } |
| |
| getValidFanPath( |
| asyncResp, *validChassisPath, chassisId, fanId, |
| std::bind_front(afterGetValidFanPath, asyncResp, chassisId, fanId)); |
| } |
| |
| inline void handleFanHead(App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId, |
| const std::string& fanId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| |
| redfish::chassis_utils::getValidChassisPath( |
| asyncResp, chassisId, |
| [asyncResp, chassisId, |
| fanId](const std::optional<std::string>& validChassisPath) { |
| if (!validChassisPath) |
| { |
| messages::resourceNotFound(asyncResp->res, "Chassis", chassisId); |
| return; |
| } |
| getValidFanPath(asyncResp, *validChassisPath, chassisId, fanId, |
| [asyncResp](const std::string&, const std::string&) { |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/Fan/Fan.json>; rel=describedby"); |
| }); |
| }); |
| } |
| |
| inline void handleFanGet(App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& chassisId, const std::string& fanId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| |
| redfish::chassis_utils::getValidChassisPath( |
| asyncResp, chassisId, |
| std::bind_front(doFanGet, asyncResp, chassisId, fanId)); |
| } |
| |
| inline void requestRoutesFan(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ThermalSubsystem/Fans/<str>/") |
| .privileges(redfish::privileges::headFan) |
| .methods(boost::beast::http::verb::head)( |
| std::bind_front(handleFanHead, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ThermalSubsystem/Fans/<str>/") |
| .privileges(redfish::privileges::getFan) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleFanGet, std::ref(app))); |
| } |
| |
| } // namespace redfish |
