| #ifndef THIRD_PARTY_GBMCWEB_REDFISH_CORE_INCLUDE_UTILS_LOCATION_UTILS_H_ |
| #define THIRD_PARTY_GBMCWEB_REDFISH_CORE_INCLUDE_UTILS_LOCATION_UTILS_H_ |
| |
| #include <algorithm> |
| #include <cstddef> |
| #include <functional> |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <unordered_set> |
| #include <utility> |
| #include <vector> |
| |
| #include "absl/functional/any_invocable.h" |
| #include "logging.hpp" |
| #include "async_resp.hpp" |
| #include "dbus_utility.hpp" |
| #include "error_messages.hpp" |
| #include "chassis_utils.hpp" |
| #include "dbus_utils.hpp" |
| #include <nlohmann/json.hpp> |
| #include "managed_store_types.hpp" |
| #include "sdbusplus/unpack_properties.hpp" |
| |
| namespace redfish { |
| namespace location_util { |
| |
| enum class PopulateLocationContextOptions { |
| kWithPartLocationContext = 0, |
| kWithOemDevpathOnly = 1, |
| kWithPartLocationContextAndOemDevpath = 2, |
| }; |
| |
| /** |
| * @brief Check if the interface is a supported connector |
| * |
| * @param[in] interface Location type interface. |
| * |
| * @return true if the interface is a supported connector |
| */ |
| inline bool isConnector(const std::string& interface) { |
| return interface == "xyz.openbmc_project.Inventory.Connector.Backplane" || |
| interface == "xyz.openbmc_project.Inventory.Connector.Bay" || |
| interface == "xyz.openbmc_project.Inventory.Connector.Connector" || |
| interface == "xyz.openbmc_project.Inventory.Connector.Embedded" || |
| interface == "xyz.openbmc_project.Inventory.Connector.Slot" || |
| interface == "xyz.openbmc_project.Inventory.Connector.Socket"; |
| } |
| |
| /** |
| * @brief Fill out location info of a resource by requesting data from the |
| * given D-Bus object. |
| * |
| * @param[in,out] asyncResp Async HTTP response. |
| * @param[in] interface Location type interface. |
| * |
| * @return location if interface is supported Connector, otherwise, return |
| * std::nullopt. |
| */ |
| inline std::optional<std::string> getLocationType( |
| const std::string& interface) { |
| if (!isConnector(interface)) { |
| return std::nullopt; |
| } |
| return interface.substr(interface.find_last_of('.') + 1); |
| } |
| |
| void getPartLocationContext(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath, |
| const std::string& locationCode = ""); |
| |
| void getLocationContextWithOemDevpath( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath, const std::string& locationCode = ""); |
| |
| void getLocationContextWithOemDevpathOnly( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath, const std::string& locationCode = ""); |
| |
| /** |
| * |
| * @brief Fill out location code of a resource by requesting data from the |
| * given D-Bus object. |
| * |
| * @param[in,out] asyncResp Async HTTP response. |
| * @param[in] service D-Bus service to query. |
| * @param[in] objPath D-Bus object to query. |
| * @param[in] location Json path of where to find the location |
| * property. |
| */ |
| inline void getLocationCode( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& service, const std::string& objPath, |
| const nlohmann::json::json_pointer& location, |
| const std::optional<std::string>& contextPath = std::nullopt) { |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| dbus_utils::getProperty<std::string>( |
| service, objPath, "xyz.openbmc_project.Inventory.Decorator.LocationCode", |
| "LocationCode", requestContext, |
| [asyncResp, location, contextPath](const boost::system::error_code ec, |
| const std::string& property) { |
| if (ec) { |
| BMCWEB_LOG_DEBUG << "DBUS response error for Location"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| asyncResp->res.jsonValue[location]["PartLocation"]["ServiceLabel"] = |
| property; |
| if (contextPath != std::nullopt) { |
| getPartLocationContext(asyncResp, location, contextPath.value(), |
| property); |
| } |
| }); |
| } |
| |
| /** |
| * @brief Fill out PartLocationContext of a redfish resource. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json path of where to put the location context |
| * @param[in] label Service label to update the location context with |
| */ |
| inline void updateLocationContext( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, const std::string& label) { |
| BMCWEB_LOG_DEBUG << "Add service label " << label |
| << " to PartLocationContext"; |
| nlohmann::json& propertyJson = |
| asyncResp->res.jsonValue[jsonPtr]["PartLocationContext"]; |
| const std::string* val = propertyJson.get_ptr<const std::string*>(); |
| if (val != nullptr && !val->empty()) { |
| propertyJson = label + "/" + *val; |
| } else { |
| propertyJson = label; |
| } |
| } |
| |
| /** |
| * @brief Fill out Oem.LocationContext.ServiceLabel of a redfish resource. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json path of where to put the location context |
| * @param[in] label Service label to update the location context with |
| */ |
| inline void updateOemServiceLabel( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, const std::string& label) { |
| asyncResp->res |
| .jsonValue[jsonPtr]["Google"]["LocationContext"]["ServiceLabel"] = label; |
| } |
| |
| /** |
| * @brief Fill out Oem devpath of a redfish resource. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json path of where to put the Oem Devpath |
| * @param[in] label Service label to update the Oem Devpath with |
| */ |
| inline void updateLocationOemDevpath( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, const std::string& label) { |
| BMCWEB_LOG_DEBUG << "update devpath" << label << "to Oem/Google/Devpath"; |
| const std::string prefix = "/phys/"; |
| nlohmann::json& propertyJson = |
| asyncResp->res.jsonValue[jsonPtr]["Oem"]["Google"]["Devpath"]; |
| std::string* val = propertyJson.get_ptr<std::string*>(); |
| if (val != nullptr && !val->empty()) { |
| if (val->rfind(prefix, 0) == 0) { |
| val->erase(0, prefix.length()); |
| propertyJson = prefix + label + "/" + *val; |
| } else { |
| BMCWEB_LOG_ERROR << "Oem devpath " << *val << " missing /phys/"; |
| return; |
| } |
| } else { |
| propertyJson = prefix + label; |
| } |
| } |
| |
| /** |
| * @brief Context for selecting the best cable among multiple attached cables. |
| * Uses RAII to trigger the completion callback when all async requests are |
| * done. |
| */ |
| struct CableSelectionContext { |
| std::optional<std::pair<std::string, std::string>> bestCable; |
| absl::AnyInvocable<void( |
| const std::optional<std::pair<std::string, std::string>>&)> |
| onComplete; |
| |
| explicit CableSelectionContext( |
| absl::AnyInvocable< |
| void(const std::optional<std::pair<std::string, std::string>>&)> |
| callback) |
| : onComplete(std::move(callback)) {} |
| |
| ~CableSelectionContext() { onComplete(bestCable); } |
| |
| CableSelectionContext(const CableSelectionContext&) = delete; |
| CableSelectionContext& operator=(const CableSelectionContext&) = delete; |
| CableSelectionContext(CableSelectionContext&&) = delete; |
| CableSelectionContext& operator=(CableSelectionContext&&) = delete; |
| }; |
| |
| /** |
| * @brief Parses given chassis subtree for object path and connection to retrive |
| * chassis location code used to fill PartLocationContext. |
| * |
| * @param[in] upstreamChassisPaths Set of chassis object paths queried. |
| * @param[in] jsonPtr Json location to fill PartLocationContext |
| * @param[in] currentLocationCode Location code of the current chassis. |
| * @param[in] withOemDevpath Whether to fill Oem Devpath. |
| * @param[in] associationPath Path used to associate with upstream chassis |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] subtree Subtree associated with chassis endpoint |
| */ |
| inline void getAssociatedChassisSubtreeCallback( |
| std::unordered_set<std::string> upstreamChassisPaths, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& currentLocationCode, |
| PopulateLocationContextOptions populateLocationContextOptions, |
| const std::string& associationPath, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| // Base case as we recurse to get upstream chassis association. |
| if (subtree.empty()) { |
| BMCWEB_LOG_DEBUG << "Chassis association not found." |
| "Must be root chassis or link is broken"; |
| std::string currentPath; |
| size_t pos = associationPath.find_last_of('/'); |
| if (pos != std::string::npos) { |
| currentPath = associationPath.substr(0, pos); |
| } |
| |
| if (currentPath.empty()) { |
| return; |
| } |
| |
| // Check for attached cables |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| |
| dbus_utils::getProperty<std::vector<std::string>>( |
| "xyz.openbmc_project.ObjectMapper", currentPath + "/attached_cables", |
| "xyz.openbmc_project.Association", "endpoints", requestContext, |
| [asyncResp, jsonPtr, populateLocationContextOptions, |
| currentLocationCode, currentPath, |
| upstreamChassisPaths](const boost::system::error_code ec, |
| const std::vector<std::string>& cableList) { |
| if (ec || cableList.empty()) { |
| return; |
| } |
| |
| auto selectionContext = std::make_shared<CableSelectionContext>( |
| [asyncResp, jsonPtr, populateLocationContextOptions, |
| upstreamChassisPaths, currentLocationCode, currentPath]( |
| const std::optional<std::pair<std::string, std::string>>& |
| bestResult) mutable { |
| if (!bestResult.has_value()) { |
| return; |
| } |
| |
| const auto& [bestLocationCode, bestCablePath] = |
| bestResult.value(); |
| |
| switch (populateLocationContextOptions) { |
| case PopulateLocationContextOptions::kWithOemDevpathOnly: |
| updateLocationOemDevpath(asyncResp, jsonPtr, |
| bestLocationCode); |
| break; |
| case PopulateLocationContextOptions::kWithPartLocationContext: |
| updateLocationContext(asyncResp, jsonPtr, bestLocationCode); |
| break; |
| case PopulateLocationContextOptions:: |
| kWithPartLocationContextAndOemDevpath: |
| updateLocationContext(asyncResp, jsonPtr, bestLocationCode); |
| updateLocationOemDevpath(asyncResp, jsonPtr, |
| bestLocationCode); |
| break; |
| } |
| |
| // Recurse upward to the cable's upstream chassis. |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, bestCablePath + "/upstream_chassis", |
| std::bind_front(getAssociatedChassisSubtreeCallback, |
| upstreamChassisPaths, jsonPtr, |
| bestLocationCode, |
| populateLocationContextOptions, |
| bestCablePath + "/upstream_chassis")); |
| }); |
| |
| for (const std::string& cablePath : cableList) { |
| managedStore::ManagedObjectStoreContext cableAssocRequestContext( |
| asyncResp); |
| // Check if the chassis is downstream of this cable. |
| dbus_utils::getProperty<std::vector<std::string>>( |
| "xyz.openbmc_project.ObjectMapper", |
| cablePath + "/downstream_chassis", |
| "xyz.openbmc_project.Association", "endpoints", |
| cableAssocRequestContext, |
| [asyncResp, cablePath, currentPath, selectionContext]( |
| const boost::system::error_code ec2, |
| const std::vector<std::string>& endpoints) mutable { |
| bool isMatchingCable = false; |
| |
| if (!ec2) { |
| isMatchingCable = |
| std::find(endpoints.begin(), endpoints.end(), |
| currentPath) != endpoints.end(); |
| } |
| |
| if (isMatchingCable) { |
| // Valid cable, so we need to get its LocationCode. |
| managedStore::ManagedObjectStoreContext cableRequestContext( |
| asyncResp); |
| dbus_utils::getProperty<std::string>( |
| "xyz.openbmc_project.EntityManager", cablePath, |
| "xyz.openbmc_project.Inventory.Decorator.LocationCode", |
| "LocationCode", cableRequestContext, |
| [selectionContext, cablePath]( |
| const boost::system::error_code ec3, |
| const std::string& cableLocationCode) mutable { |
| if (!ec3) { |
| if (!selectionContext->bestCable || |
| cableLocationCode < |
| selectionContext->bestCable->first) { |
| selectionContext->bestCable = {cableLocationCode, |
| cablePath}; |
| } |
| } |
| }); |
| } |
| }); |
| } |
| }); |
| |
| return; |
| } |
| |
| if (subtree.size() > 1) { |
| BMCWEB_LOG_ERROR << "Found multiple upstream chassis."; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| auto chassisPathToConnMap = subtree.begin(); |
| |
| // Upstream chassis. |
| const std::string& chassisPath = chassisPathToConnMap->first; |
| if (!upstreamChassisPaths.emplace(chassisPath).second) { |
| BMCWEB_LOG_ERROR << "Loop detected in upstream chassis associations."; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| const dbus::utility::MapperServiceMap& serviceMap = |
| chassisPathToConnMap->second; |
| if (serviceMap.empty()) { |
| BMCWEB_LOG_ERROR << "Associated chassis obj path " << chassisPath |
| << " has no service mapping."; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| if (serviceMap.size() > 1) { |
| BMCWEB_LOG_ERROR << "Associated chassis path " << chassisPath |
| << " found in multiple connections"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // Get service name to retrieve upstream chassis location code property. |
| const std::string& service = serviceMap.begin()->first; |
| |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| dbus_utils::getProperty<std::string>( |
| service, chassisPath, |
| "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode", |
| requestContext, |
| [asyncResp, jsonPtr, chassisPath, currentLocationCode, |
| upstreamChassisPaths, |
| populateLocationContextOptions](const boost::system::error_code ec2, |
| const std::string& locationCode) { |
| if (ec2) { |
| BMCWEB_LOG_DEBUG << "DBUS response error for Location, ec: " |
| << ec2.message(); |
| return; |
| } |
| |
| std::string nextLocationCode; |
| if (currentLocationCode != locationCode) { |
| switch (populateLocationContextOptions) { |
| case PopulateLocationContextOptions::kWithOemDevpathOnly: |
| updateLocationOemDevpath(asyncResp, jsonPtr, locationCode); |
| break; |
| case PopulateLocationContextOptions::kWithPartLocationContext: |
| updateLocationContext(asyncResp, jsonPtr, locationCode); |
| break; |
| case PopulateLocationContextOptions:: |
| kWithPartLocationContextAndOemDevpath: |
| updateLocationContext(asyncResp, jsonPtr, locationCode); |
| updateLocationOemDevpath(asyncResp, jsonPtr, locationCode); |
| break; |
| } |
| } else { |
| // Continue checking to see if the locationCode matches |
| nextLocationCode = currentLocationCode; |
| } |
| |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, chassisPath + "/contained_by", |
| std::bind_front(getAssociatedChassisSubtreeCallback, |
| upstreamChassisPaths, jsonPtr, nextLocationCode, |
| populateLocationContextOptions, |
| chassisPath + "/contained_by")); |
| }); |
| } |
| |
| /** |
| * @brief Recursively gets LocationCode for upstream chassis to populate |
| * PartLocationContext. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json location to fill PartLocationContext |
| * @param[in] associationPath Path used to associate with upstream chassis |
| */ |
| inline void getPartLocationContext( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath, const std::string& locationCode) { |
| BMCWEB_LOG_DEBUG << "Get chassis endpoints associated with " |
| << associationPath; |
| // Set of chassis object paths used to detect cycle as we resolve usptream |
| // chassis associations to get to root chassis to create PartLocationContext |
| std::unordered_set<std::string> upstreamChassisPaths; |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, associationPath, |
| std::bind_front(getAssociatedChassisSubtreeCallback, |
| std::move(upstreamChassisPaths), jsonPtr, locationCode, |
| PopulateLocationContextOptions::kWithPartLocationContext, |
| associationPath)); |
| } |
| |
| /** |
| * @brief Recursively gets LocationCode for upstream chassis to populate oem |
| * devpath. This translates "/phys/A/SL" to "/phys/.../DC_DC_A/DC_A/A/SL" |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json location to fill PartLocationContext |
| * @param[in] associationPath Path used to associate with upstream chassis |
| */ |
| inline void getLocationContextWithOemDevpath( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath, const std::string& locationCode) { |
| BMCWEB_LOG_DEBUG << "Get chassis endpoints associated with " |
| << associationPath |
| << " for location context and oem devpath"; |
| // Set of chassis object paths used to detect cycle as we resolve upstream |
| // chassis associations to get to root chassis to create PartLocationContext |
| std::unordered_set<std::string> upstreamChassisPaths; |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, associationPath, |
| std::bind_front( |
| getAssociatedChassisSubtreeCallback, std::move(upstreamChassisPaths), |
| jsonPtr, locationCode, |
| PopulateLocationContextOptions::kWithPartLocationContextAndOemDevpath, |
| associationPath)); |
| } |
| |
| /** |
| * @brief Gets LocationContext for a given chassis. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json location to fill PartLocationContext |
| * @param[in] associationPath Path used to associate with upstream chassis |
| */ |
| inline void getLocationContextWithOemDevpathOnly( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath, const std::string& locationCode) { |
| BMCWEB_LOG_DEBUG << "Get chassis endpoints associated with " |
| << associationPath |
| << " for location context and oem devpath"; |
| // Set of chassis object paths used to detect cycle as we resolve upstream |
| // chassis associations to get to root chassis to create PartLocationContext |
| std::unordered_set<std::string> upstreamChassisPaths; |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, associationPath, |
| std::bind_front(getAssociatedChassisSubtreeCallback, |
| std::move(upstreamChassisPaths), jsonPtr, locationCode, |
| PopulateLocationContextOptions::kWithOemDevpathOnly, |
| associationPath)); |
| } |
| |
| /** |
| * @brief Fill out location code of a resource from given managed objects. |
| * |
| * @param[in,out] aResp Async HTTP response. |
| * @param[in] objPath D-Bus object to query. |
| * @param[in] interface D-Bus interface to query. |
| * @param[in] jsonPtr Json pointer to populate. |
| * @param[in] managedObjects Managed objects. |
| */ |
| inline void getLocationCodeFromManagedObject( |
| const std::shared_ptr<bmcweb::AsyncResp>& aResp, const std::string& objPath, |
| const std::string& interface, const nlohmann::json::json_pointer& jsonPtr, |
| const dbus::utility::ManagedObjectType& managedObjects) { |
| dbus::utility::DBusPropertiesMap properties; |
| dbus_utils::getPropertiesFromManagedObjects(managedObjects, objPath, |
| interface, properties); |
| |
| const std::string* locationProperty = nullptr; |
| |
| const bool success = sdbusplus::unpackPropertiesNoThrow( |
| dbus_utils::UnpackErrorPrinter(), properties, "LocationCode", |
| locationProperty); |
| |
| if (!success) { |
| messages::internalError(aResp->res); |
| return; |
| } |
| |
| if (locationProperty != nullptr) { |
| aResp->res.jsonValue[jsonPtr]["PartLocation"]["ServiceLabel"] = |
| *locationProperty; |
| } |
| } |
| |
| /** |
| * @brief Validate the association subtree. |
| * |
| * @param[in] upstreamChassisPaths Set of chassis object paths queried. |
| * @param[in] subtree Subtree associated with chassis endpoint |
| */ |
| |
| inline bool validateSubtree( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| if (subtree.empty()) { |
| BMCWEB_LOG_DEBUG << "Chassis association not found." |
| "Must be root chassis or link is broken"; |
| return false; |
| } |
| if (subtree.size() > 1) { |
| BMCWEB_LOG_ERROR << "Found multiple upstream chassis."; |
| messages::internalError(asyncResp->res); |
| return false; |
| } |
| auto chassisPathToConnMap = subtree.begin(); |
| // Upstream chassis. |
| const std::string& chassisPath = chassisPathToConnMap->first; |
| const dbus::utility::MapperServiceMap& serviceMap = |
| chassisPathToConnMap->second; |
| if (serviceMap.empty()) { |
| BMCWEB_LOG_ERROR << "Associated chassis obj path " << chassisPath |
| << " has no service mapping."; |
| messages::internalError(asyncResp->res); |
| return false; |
| } |
| if (serviceMap.size() > 1) { |
| BMCWEB_LOG_ERROR << "Associated chassis path " << chassisPath |
| << " found in multiple connections"; |
| messages::internalError(asyncResp->res); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * @brief Parses given chassis subtree for object path and connection to retrive |
| * chassis location code used to fill Oem ServiceLabel. |
| * |
| * @param[in] jsonPtr Json location to fill PartLocationContext |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] subtree Subtree associated with chassis endpoint |
| */ |
| inline void getOemServiceLabelCallback( |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| if (!validateSubtree(asyncResp, subtree)) { |
| BMCWEB_LOG_DEBUG << "Not a valid subree"; |
| return; |
| } |
| auto chassisPathToConnMap = subtree.begin(); |
| |
| // Upstream chassis. |
| const std::string& chassisPath = chassisPathToConnMap->first; |
| const dbus::utility::MapperServiceMap& serviceMap = |
| chassisPathToConnMap->second; |
| // Get service name to retrieve upstream chassis location code property. |
| const std::string& service = serviceMap.begin()->first; |
| |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| dbus_utils::getProperty<std::string>( |
| service, chassisPath, |
| "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode", |
| requestContext, |
| [asyncResp, jsonPtr, chassisPath](const boost::system::error_code ec2, |
| const std::string& locationCode) { |
| if (ec2) { |
| BMCWEB_LOG_DEBUG << "DBUS response error for Location, ec: " |
| << ec2.message(); |
| return; |
| } |
| updateOemServiceLabel(asyncResp, jsonPtr, locationCode); |
| }); |
| } |
| |
| /** |
| * @brief gets LocationCode for upstream chassis to populate |
| * Oem ServiceLabel. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json location to fill ServiceLabel |
| * @param[in] associationPath Path used to associate with upstream chassis |
| */ |
| inline void getOemServiceLabel( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath) { |
| // Oem.Google.LocationContext.ServiceLabel is ServiceLabel inherited from |
| // parent replaceable resource. |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, associationPath, |
| std::bind_front(getOemServiceLabelCallback, jsonPtr)); |
| } |
| |
| /** |
| * @brief Fill out Oem PartLocationContext of a redfish resource. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json path of where to put the location context |
| * @param[in] label Service label to update the location context with |
| */ |
| inline void updateOemPartLocationContext( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, const std::string& label) { |
| nlohmann::json& propertyJson = |
| asyncResp->res.jsonValue[jsonPtr]["Google"]["LocationContext"] |
| ["PartLocationContext"]; |
| const std::string* val = propertyJson.get_ptr<const std::string*>(); |
| if (val != nullptr && !val->empty()) { |
| propertyJson = label + "/" + *val; |
| } else { |
| propertyJson = label; |
| } |
| } |
| |
| /** |
| * @brief Parses given chassis subtree for object path and connection to retrive |
| * chassis location code used to fill Oem PartLocationContext. |
| * |
| * @param[in] upstreamChassisPaths Set of chassis object paths queried. |
| * @param[in] jsonPtr Json location to fill PartLocationContext |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] subtree Subtree associated with chassis endpoint |
| */ |
| inline void getOemPartLocationContextCallback( |
| std::unordered_set<std::string> upstreamChassisPaths, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| if (!validateSubtree(asyncResp, subtree)) { |
| BMCWEB_LOG_DEBUG << "Not a valid subree"; |
| return; |
| } |
| |
| auto chassisPathToConnMap = subtree.begin(); |
| // Upstream chassis. |
| const std::string& chassisPath = chassisPathToConnMap->first; |
| if (!upstreamChassisPaths.emplace(chassisPath).second) { |
| BMCWEB_LOG_ERROR << "Loop detected in upstream chassis associations."; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| const dbus::utility::MapperServiceMap& serviceMap = |
| chassisPathToConnMap->second; |
| |
| // Get service name to retrieve upstream chassis location code property. |
| const std::string& service = serviceMap.begin()->first; |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| dbus_utils::getProperty<std::string>( |
| service, chassisPath, |
| "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode", |
| requestContext, |
| [asyncResp, jsonPtr, chassisPath, upstreamChassisPaths]( |
| const boost::system::error_code ec2, |
| const std::string& locationCode) { |
| if (ec2) { |
| BMCWEB_LOG_DEBUG << "DBUS response error for Location, ec: " |
| << ec2.message(); |
| return; |
| } |
| |
| updateOemPartLocationContext(asyncResp, jsonPtr, locationCode); |
| |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, chassisPath + "/contained_by", |
| std::bind_front(getOemPartLocationContextCallback, |
| upstreamChassisPaths, jsonPtr)); |
| }); |
| } |
| |
| /** |
| * @brief Recursively gets LocationCode for upstream chassis to populate |
| * Oem PartLocationContext. |
| * |
| * @param[in,out] asyncResp Async HTTP response |
| * @param[in] jsonPtr Json location to fill PartLocationContext |
| * @param[in] associationPath Path used to associate with upstream chassis |
| */ |
| inline void getOemPartLocationContext( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const nlohmann::json::json_pointer& jsonPtr, |
| const std::string& associationPath) { |
| // Oem.Google.LocationContext.PartLocationContext is PartLocationContext |
| // inherited from parent replaceable resource. |
| asyncResp->res |
| .jsonValue[jsonPtr]["Google"]["LocationContext"]["PartLocationContext"] = |
| ""; |
| std::unordered_set<std::string> upstreamChassisPaths; |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, associationPath, |
| [jsonPtr, upstreamChassisPaths]( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| if (!validateSubtree(asyncResp, subtree)) { |
| BMCWEB_LOG_DEBUG << "Not a valid subree"; |
| return; |
| } |
| // Upstream chassis. |
| const std::string& chassisPath = subtree.begin()->first; |
| |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| chassis_utils::getAssociatedChassisSubtree( |
| asyncResp, chassisPath + "/contained_by", |
| std::bind_front(getOemPartLocationContextCallback, |
| upstreamChassisPaths, jsonPtr)); |
| }); |
| } |
| |
| } // namespace location_util |
| } // namespace redfish |
| |
| #endif // THIRD_PARTY_GBMCWEB_REDFISH_CORE_INCLUDE_UTILS_LOCATION_UTILS_H_ |
