| #pragma once |
| |
| #include "bmcweb_config.h" |
| |
| #include "aggregation_utils.hpp" |
| #include "dbus_utility.hpp" |
| #include "error_messages.hpp" |
| #include "http_client.hpp" |
| #include "http_connection.hpp" |
| #include "managed_store.hpp" |
| #include "request_stats.hpp" |
| |
| #include <boost/algorithm/string/predicate.hpp> |
| |
| #include <array> |
| #include <cstdint> |
| #include <random> |
| |
| #ifdef UNIT_TEST_BUILD |
| #include "test/g3/mock_managed_store.hpp" // NOLINT |
| #endif |
| |
| namespace redfish |
| { |
| |
| constexpr unsigned int aggregatorReadBodyLimit = 50 * 1024 * 1024; // 50MB |
| |
| enum class Result : std::uint8_t |
| { |
| LocalHandle, |
| NoLocalHandle |
| }; |
| |
| enum class SearchType : std::uint8_t |
| { |
| Collection, |
| CollOrCon, |
| ContainsSubordinate, |
| Resource |
| }; |
| |
| struct RdeSatelliteConfig |
| { |
| std::string name; |
| std::string vid; |
| std::string udevid; |
| std::string usbport; |
| std::string objectpath; |
| }; |
| |
| // clang-format off |
| // These are all of the properties as of version 2022.2 of the Redfish Resource |
| // and Schema Guide whose Type is "string (URI)" and the name does not end in a |
| // case-insensitive form of "uri". That version of the schema is associated |
| // with version 1.16.0 of the Redfish Specification. Going forward, new URI |
| // properties should end in URI so this list should not need to be maintained as |
| // the spec is updated. NOTE: These have been pre-sorted in order to be |
| // compatible with binary search |
| constexpr std::array nonUriProperties{ |
| "@Redfish.ActionInfo", |
| // "@odata.context", // We can't fix /redfish/v1/$metadata URIs |
| "@odata.id", |
| // "Destination", // Only used by EventService and won't be a Redfish URI |
| // "HostName", // Isn't actually a Redfish URI |
| "Image", |
| "MetricProperty", |
| // "OriginOfCondition", // Is URI when in request, but is object in response |
| "TaskMonitor", |
| "target", // normal string, but target URI for POST to invoke an action |
| }; |
| // clang-format on |
| |
| // Search the top collection array to determine if the passed URI is of a |
| // desired type |
| inline bool searchCollectionsArray(std::string_view uri, |
| const SearchType searchType) |
| { |
| boost::system::result<boost::urls::url> parsedUrl = |
| boost::urls::parse_relative_ref(uri); |
| |
| if (!parsedUrl) |
| { |
| BMCWEB_LOG_ERROR << "Failed to get target URI from " << uri; |
| return false; |
| } |
| |
| parsedUrl->normalize(); |
| boost::urls::segments_ref segments = parsedUrl->segments(); |
| if (!segments.is_absolute()) |
| { |
| return false; |
| } |
| |
| // The passed URI must begin with "/redfish/v1", but we have to strip it |
| // from the URI since topCollections does not include it in its URIs. |
| if (segments.size() < 2) |
| { |
| return false; |
| } |
| if (segments.front() != "redfish") |
| { |
| return false; |
| } |
| segments.erase(segments.begin()); |
| if (segments.front() != "v1") |
| { |
| return false; |
| } |
| segments.erase(segments.begin()); |
| |
| // Exclude the trailing "/" if it exists such as in "/redfish/v1/". |
| if (!segments.empty() && segments.back().empty()) |
| { |
| segments.pop_back(); |
| } |
| |
| // If no segments then the passed URI was either "/redfish/v1" or |
| // "/redfish/v1/". |
| if (segments.empty()) |
| { |
| return (searchType == SearchType::ContainsSubordinate) || |
| (searchType == SearchType::CollOrCon); |
| } |
| std::string_view url = segments.buffer(); |
| const auto* it = std::ranges::lower_bound(topCollections, url); |
| if (it == topCollections.end()) |
| { |
| // parsedUrl is alphabetically after the last entry in the array so it |
| // can't be a top collection or up tree from a top collection |
| return false; |
| } |
| |
| boost::urls::url collectionUrl(*it); |
| boost::urls::segments_view collectionSegments = collectionUrl.segments(); |
| boost::urls::segments_view::iterator itCollection = |
| collectionSegments.begin(); |
| const boost::urls::segments_view::const_iterator endCollection = |
| collectionSegments.end(); |
| |
| // Each segment in the passed URI should match the found collection |
| for (const auto& segment : segments) |
| { |
| if (itCollection == endCollection) |
| { |
| // Leftover segments means the target is for an aggregation |
| // supported resource |
| return searchType == SearchType::Resource; |
| } |
| |
| if (segment != (*itCollection)) |
| { |
| return false; |
| } |
| itCollection++; |
| } |
| |
| // No remaining segments means the passed URI was a top level collection |
| if (searchType == SearchType::Collection) |
| { |
| return itCollection == endCollection; |
| } |
| if (searchType == SearchType::ContainsSubordinate) |
| { |
| return itCollection != endCollection; |
| } |
| |
| // Return this check instead of "true" in case other SearchTypes get added |
| return searchType == SearchType::CollOrCon; |
| } |
| |
| // Strip query params which are incompatible with aggregation. |
| // Note, this still doesn't work for collections that might return less than the |
| // complete collection by default, but hopefully those are rare/nonexistent in |
| // top collections. bmcweb doesn't implement any of these. |
| inline void parameterRemove(crow::Request& localReq) |
| { |
| boost::urls::url& urlNew = localReq.mutableUrl(); |
| auto paramsIt = urlNew.params().begin(); |
| bool foundSkip = false; |
| while (paramsIt != urlNew.params().end()) |
| { |
| const boost::urls::param& param = *paramsIt; |
| |
| // Plugins will not apply correctly to resources pulled in by offloading |
| // $expand to a satellite BMC. Don't forward $expand in that case. |
| if constexpr (enablePlatform22) |
| { |
| if (param.key == "$expand") |
| { |
| BMCWEB_LOG_DEBUG << "Erasing $expand from forwarded request"; |
| paramsIt = urlNew.params().erase(paramsIt); |
| continue; |
| } |
| } |
| |
| // By the spec, no other params should be provided with only. Don't |
| // forward any params and let the aggregating BMC handle them. |
| if (param.key == "only") |
| { |
| BMCWEB_LOG_DEBUG << |
| "Erasing all params from request to top level collection"; |
| urlNew.params().clear(); |
| foundSkip = false; |
| break; |
| } |
| |
| if (param.key == "$skip") |
| { |
| foundSkip = true; |
| } |
| paramsIt++; |
| } |
| |
| if (foundSkip) |
| { |
| // Remove $skip and any other param that is supposed to processed after |
| // it. Applying $skip twice would produce different results. |
| // Forwarding just the non-$skip params would result in partially |
| // processing the params in the wrong order. |
| paramsIt = urlNew.params().begin(); |
| while (paramsIt != urlNew.params().end()) |
| { |
| const boost::urls::param& param = *paramsIt; |
| // According to the Redfish spec, $filter is the only param that is |
| // processed before $skip and is thus safe to be forwarded. All |
| // others need to be removed |
| if (param.key != "$filter") |
| { |
| BMCWEB_LOG_DEBUG << "Erasing \"" << param.key |
| << "\" param from request to top level collection"; |
| paramsIt = urlNew.params().erase(paramsIt); |
| continue; |
| } |
| // Pass $filter parameter |
| paramsIt++; |
| } |
| } |
| localReq.target(urlNew.buffer()); |
| } |
| |
| // Determines if the passed property contains a URI. Those property names |
| // either end with a case-insensitive version of "uri" or are specifically |
| // defined in the above array. |
| inline bool isPropertyUri(std::string_view propertyName) |
| { |
| return boost::iends_with(propertyName, "uri") || |
| std::binary_search(nonUriProperties.begin(), nonUriProperties.end(), |
| propertyName); |
| } |
| |
| static inline void addPrefixToStringItem(std::string& strValue, |
| std::string_view prefix) |
| { |
| // Make sure the value is a properly formatted URI |
| auto parsed = boost::urls::parse_relative_ref(strValue); |
| if (!parsed) |
| { |
| BMCWEB_LOG_CRITICAL << "Couldn't parse URI from resource " << strValue; |
| return; |
| } |
| |
| boost::urls::url_view thisUrl = *parsed; |
| |
| // We don't need to aggregate JsonSchemas due to potential issues such as |
| // version mismatches between aggregator and satellite BMCs. For now |
| // assume that the aggregator has all the schemas and versions that the |
| // aggregated server has. |
| if (crow::utility::readUrlSegments(thisUrl, "redfish", "v1", "JsonSchemas", |
| crow::utility::OrMorePaths())) |
| { |
| BMCWEB_LOG_DEBUG << "Skipping JsonSchemas URI prefix fixing"; |
| return; |
| } |
| |
| // The first two segments should be "/redfish/v1". We need to check that |
| // before we can search topCollections |
| if (!crow::utility::readUrlSegments(thisUrl, "redfish", "v1", |
| crow::utility::OrMorePaths())) |
| { |
| return; |
| } |
| |
| // Check array adding a segment each time until collection is identified |
| // Add prefix to segment after the collection |
| const boost::urls::segments_view urlSegments = thisUrl.segments(); |
| bool addedPrefix = false; |
| boost::urls::url url("/"); |
| boost::urls::segments_view::iterator it = urlSegments.begin(); |
| const boost::urls::segments_view::const_iterator end = urlSegments.end(); |
| |
| // Skip past the leading "/redfish/v1" |
| it++; |
| it++; |
| for (; it != end; it++) |
| { |
| // Trailing "/" will result in an empty segment. In that case we need |
| // to return so we don't apply a prefix to top level collections such |
| // as "/redfish/v1/Chassis/" |
| if ((*it).empty()) |
| { |
| return; |
| } |
| |
| if (std::binary_search(topCollections.begin(), topCollections.end(), |
| url.buffer())) |
| { |
| std::string collectionItem(prefix); |
| collectionItem += "_" + (*it); |
| url.segments().push_back(collectionItem); |
| it++; |
| addedPrefix = true; |
| break; |
| } |
| |
| url.segments().push_back(*it); |
| } |
| |
| // Finish constructing the URL here (if needed) to avoid additional checks |
| for (; it != end; it++) |
| { |
| url.segments().push_back(*it); |
| } |
| |
| if (addedPrefix) |
| { |
| url.segments().insert(url.segments().begin(), {"redfish", "v1"}); |
| // Preserve the fragment from the original URL |
| if (thisUrl.has_fragment()) |
| { |
| url.set_fragment(thisUrl.fragment()); |
| } |
| strValue = url.buffer(); |
| } |
| } |
| |
| static inline void addPrefixToItem(nlohmann::json& item, |
| std::string_view prefix) |
| { |
| std::string* strValue = item.get_ptr<std::string*>(); |
| if (strValue == nullptr) |
| { |
| BMCWEB_LOG_CRITICAL << "Field wasn't a string????"; |
| return; |
| } |
| addPrefixToStringItem(*strValue, prefix); |
| item = *strValue; |
| } |
| |
| static inline int generateRandomInt() |
| { |
| std::random_device randomDevice; |
| std::mt19937 generator(randomDevice()); |
| std::uniform_int_distribution<> distribution(1, 9999); |
| int randomNumber = distribution(generator); |
| return randomNumber; |
| } |
| |
| static inline void addAggregatedHeaders(crow::Response& asyncResp, |
| const crow::Response& resp, |
| std::string_view prefix) |
| { |
| if (!resp.getHeaderValue("Content-Type").empty()) |
| { |
| asyncResp.addHeader(boost::beast::http::field::content_type, |
| resp.getHeaderValue("Content-Type")); |
| } |
| if (!resp.getHeaderValue("Allow").empty()) |
| { |
| asyncResp.addHeader(boost::beast::http::field::allow, |
| resp.getHeaderValue("Allow")); |
| } |
| std::string_view header = resp.getHeaderValue("Location"); |
| if (!header.empty()) |
| { |
| std::string location(header); |
| addPrefixToStringItem(location, prefix); |
| asyncResp.addHeader(boost::beast::http::field::location, location); |
| } |
| if (!resp.getHeaderValue("Retry-After").empty()) |
| { |
| asyncResp.addHeader(boost::beast::http::field::retry_after, |
| resp.getHeaderValue("Retry-After")); |
| } |
| // TODO: we need special handling for Link Header Value |
| } |
| |
| // Fix HTTP headers which appear in responses from Task resources among others |
| static inline void addPrefixToHeadersInResp(nlohmann::json& json, |
| std::string_view prefix) |
| { |
| // The passed in "HttpHeaders" should be an array of headers |
| nlohmann::json::array_t* array = json.get_ptr<nlohmann::json::array_t*>(); |
| if (array == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Field wasn't an array_t????"; |
| return; |
| } |
| |
| for (nlohmann::json& item : *array) |
| { |
| // Each header is a single string with the form "<Field>: <Value>" |
| std::string* strHeader = item.get_ptr<std::string*>(); |
| if (strHeader == nullptr) |
| { |
| BMCWEB_LOG_CRITICAL << "Field wasn't a string????"; |
| continue; |
| } |
| |
| constexpr std::string_view location = "Location: "; |
| if (strHeader->starts_with(location)) |
| { |
| std::string header = strHeader->substr(location.size()); |
| addPrefixToStringItem(header, prefix); |
| *strHeader = std::string(location) + header; |
| } |
| } |
| } |
| |
| // Search the json for all URIs and add the supplied prefix if the URI is for |
| // an aggregated resource. |
| static inline void addPrefixes(nlohmann::json& json, std::string_view prefix) |
| { |
| nlohmann::json::object_t* object = |
| json.get_ptr<nlohmann::json::object_t*>(); |
| if (object != nullptr) |
| { |
| for (std::pair<const std::string, nlohmann::json>& item : *object) |
| { |
| if (isPropertyUri(item.first)) |
| { |
| addPrefixToItem(item.second, prefix); |
| continue; |
| } |
| |
| // "HttpHeaders" contains HTTP headers. Among those we need to |
| // attempt to fix the "Location" header |
| if (item.first == "HttpHeaders") |
| { |
| addPrefixToHeadersInResp(item.second, prefix); |
| continue; |
| } |
| |
| // Recusively parse the rest of the json |
| addPrefixes(item.second, prefix); |
| } |
| return; |
| } |
| nlohmann::json::array_t* array = json.get_ptr<nlohmann::json::array_t*>(); |
| if (array != nullptr) |
| { |
| for (nlohmann::json& item : *array) |
| { |
| addPrefixes(item, prefix); |
| } |
| } |
| } |
| |
| inline std::unordered_map<std::string, std::string> |
| rdePrefixMap({{"/xyz/openbmc_project/rde_devices/1_1_1_1", "BCX5VT"}, // NOLINT |
| {"/xyz/openbmc_project/rde_devices/1_1_2_1", "A61MJ0"}, |
| {"/xyz/openbmc_project/rde_devices/1_1_3_1", "K298LC"}, |
| {"/xyz/openbmc_project/rde_devices/1_1_4_1", "2HMMCS"}}); |
| |
| inline std::unordered_map<std::string, std::string> |
| rdeServiceLabelMap({{"BCX5VT", "DOWNLINK"}, // NOLINT |
| {"A61MJ0", "DOWNLINK"}, |
| {"K298LC", "DOWNLINK"}, |
| {"2HMMCS", "PCIE0"}}); |
| |
| inline static bool generatePrefix(const std::string& objPath, std::string& prefix) |
| { |
| const auto& it = rdePrefixMap.find(objPath); |
| if (it == rdePrefixMap.end()) |
| { |
| BMCWEB_LOG_DEBUG << "objPath does not exist in prefix map " << objPath |
| << "\n"; |
| return false; |
| } |
| prefix = it->second; |
| return true; |
| } |
| |
| static inline bool isMemberStartsWithKnownPrefix(const std::string& memberName) |
| { |
| BMCWEB_LOG_DEBUG << "isMemberStartsWithKnownPrefix"; |
| for (auto const& [path, prefix] : rdePrefixMap) |
| { |
| BMCWEB_LOG_DEBUG << "path " << path << " " << prefix; |
| if (memberName.starts_with(prefix)) |
| { |
| BMCWEB_LOG_DEBUG << " Known prefix " << memberName; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| inline boost::system::error_code aggregationRetryHandler(unsigned int respCode) |
| { |
| // Allow all response codes because we want to surface any satellite |
| // issue to the client |
| BMCWEB_LOG_DEBUG << "Received " << respCode << " response from satellite"; |
| return boost::system::errc::make_error_code(boost::system::errc::success); |
| } |
| |
| inline crow::ConnectionPolicy getAggregationPolicy() |
| { |
| return {.maxRetryAttempts = 1, |
| .requestByteLimit = aggregatorReadBodyLimit, |
| .maxConnections = 20, |
| .retryPolicyAction = "TerminateAfterRetries", |
| .retryIntervalSecs = std::chrono::seconds(0), |
| .invalidResp = aggregationRetryHandler}; |
| } |
| |
| class RedfishAggregator |
| { |
| private: |
| crow::HttpClient client; |
| |
| RedfishAggregator() : |
| client(std::make_shared<crow::ConnectionPolicy>(getAggregationPolicy())) |
| { |
| getSatelliteConfigs(constructorCallback); |
| } |
| |
| // Dummy callback used by the Constructor so that it can report the number |
| // of satellite configs when the class is first created |
| static void constructorCallback( |
| const boost::system::error_code& ec, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo, |
| const std::unordered_map<std::string, RdeSatelliteConfig>& |
| rdeSatelliteInfo) |
| { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "Something went wrong while querying dbus!"; |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "There were " |
| << std::to_string(satelliteInfo.size()) |
| << " satellite configs found at startup"; |
| BMCWEB_LOG_DEBUG << "There were " |
| << std::to_string(rdeSatelliteInfo.size()) |
| << " RDE Device configs found at startup"; |
| } |
| |
| // Search D-Bus objects for satellite config objects and add their |
| // information if valid |
| static void findSatelliteConfigs( |
| const dbus::utility::ManagedObjectType& objects, |
| std::unordered_map<std::string, boost::urls::url>& satelliteInfo, |
| std::unordered_map<std::string, RdeSatelliteConfig>& rdeSatelliteInfo) |
| { |
| for (const auto& objectPath : objects) |
| { |
| for (const auto& interface : objectPath.second) |
| { |
| if (interface.first == |
| "xyz.openbmc_project.Configuration.SatelliteController") |
| { |
| BMCWEB_LOG_DEBUG << "Found Satellite Controller at " |
| << objectPath.first.str; |
| |
| if (!satelliteInfo.empty()) |
| { |
| BMCWEB_LOG_ERROR |
| << "Redfish Aggregation only supports one satellite!"; |
| BMCWEB_LOG_DEBUG << "Clearing all satellite data"; |
| satelliteInfo.clear(); |
| return; |
| } |
| |
| // For now assume there will only be one satellite config. |
| // Assign it the name/prefix "5B247A" |
| addSatelliteConfig("5B247A", interface.second, |
| satelliteInfo); |
| } |
| else if ( |
| interface.first == |
| "xyz.openbmc_project.Configuration.RdeSatelliteController") |
| { |
| BMCWEB_LOG_DEBUG << "Found RDE Satellite Controller at " |
| << objectPath.first.str; |
| addRdeSatelliteConfig(interface.second, rdeSatelliteInfo); |
| } |
| } |
| } |
| } |
| |
| // Parse the properties of a satellite config object and add the |
| // configuration if the properties are valid |
| static void addSatelliteConfig( |
| const std::string& name, |
| const dbus::utility::DBusPropertiesMap& properties, |
| std::unordered_map<std::string, boost::urls::url>& satelliteInfo) |
| { |
| boost::urls::url url; |
| |
| for (const auto& prop : properties) |
| { |
| if (prop.first == "Hostname") |
| { |
| const std::string* propVal = |
| std::get_if<std::string>(&prop.second); |
| if (propVal == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Invalid Hostname value"; |
| return; |
| } |
| url.set_host(*propVal); |
| } |
| |
| else if (prop.first == "Port") |
| { |
| const uint64_t* propVal = std::get_if<uint64_t>(&prop.second); |
| if (propVal == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Invalid Port value"; |
| return; |
| } |
| |
| if (*propVal > std::numeric_limits<uint16_t>::max()) |
| { |
| BMCWEB_LOG_ERROR << "Port value out of range"; |
| return; |
| } |
| url.set_port(std::to_string(static_cast<uint16_t>(*propVal))); |
| } |
| |
| else if (prop.first == "AuthType") |
| { |
| const std::string* propVal = |
| std::get_if<std::string>(&prop.second); |
| if (propVal == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Invalid AuthType value"; |
| return; |
| } |
| |
| // For now assume authentication not required to communicate |
| // with the satellite BMC |
| if (*propVal != "None") |
| { |
| BMCWEB_LOG_ERROR |
| << "Unsupported AuthType value: " << *propVal |
| << ", only \"none\" is supported"; |
| return; |
| } |
| url.set_scheme("http"); |
| } |
| } // Finished reading properties |
| |
| // Make sure all required config information was made available |
| if (url.host().empty()) |
| { |
| BMCWEB_LOG_ERROR << "Satellite config " << name << " missing Host"; |
| return; |
| } |
| |
| if (!url.has_port()) |
| { |
| BMCWEB_LOG_ERROR << "Satellite config " << name << " missing Port"; |
| return; |
| } |
| |
| if (!url.has_scheme()) |
| { |
| BMCWEB_LOG_ERROR << "Satellite config " << name |
| << " missing AuthType"; |
| return; |
| } |
| |
| std::string resultString; |
| auto result = satelliteInfo.insert_or_assign(name, std::move(url)); |
| if (result.second) |
| { |
| resultString = "Added new satellite config "; |
| } |
| else |
| { |
| resultString = "Updated existing satellite config "; |
| } |
| |
| BMCWEB_LOG_DEBUG << resultString << name << " at " |
| << result.first->second.scheme() << "://" |
| << result.first->second.encoded_host_and_port(); |
| } |
| |
| // Parse the properties of a RDE Device config object and add the |
| // configuration if the properties are valid |
| static void addRdeSatelliteConfig( |
| const dbus::utility::DBusPropertiesMap& properties, |
| std::unordered_map<std::string, RdeSatelliteConfig>& rdeSatelliteInfo) |
| { |
| RdeSatelliteConfig rdeConfig; |
| std::string name; |
| for (const auto& prop : properties) |
| { |
| if (prop.first == "Name") |
| { |
| const std::string* propVal = |
| std::get_if<std::string>(&prop.second); |
| if (propVal == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Invalid Name value"; |
| return; |
| } |
| rdeConfig.name = *propVal; |
| } |
| else if (prop.first == "VID") |
| { |
| const std::string* propVal = |
| std::get_if<std::string>(&prop.second); |
| if (propVal == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Invalid VID value"; |
| return; |
| } |
| rdeConfig.vid = *propVal; |
| } |
| else if (prop.first == "UDEVID") |
| { |
| const std::string* propVal = |
| std::get_if<std::string>(&prop.second); |
| if (propVal == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Invalid UDEVID value"; |
| return; |
| } |
| rdeConfig.udevid = *propVal; |
| } |
| else if (prop.first == "USBPORT") |
| { |
| const std::string* propVal = |
| std::get_if<std::string>(&prop.second); |
| if (propVal == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Invalid USBPORT value"; |
| return; |
| } |
| rdeConfig.usbport = *propVal; |
| } |
| } // Finished reading properties |
| |
| if (rdeConfig.udevid.empty()) |
| { |
| BMCWEB_LOG_ERROR << "Empty udevid"; |
| return; |
| } |
| rdeConfig.objectpath = |
| "/xyz/openbmc_project/rde_devices/" + rdeConfig.udevid; |
| |
| // Set the prefix to a random string 'E0SB8D' |
| // (TODO) Generate a unique random prefix for each RDE Device |
| if constexpr (bmcwebEnableRdeDevice) |
| { |
| if (!generatePrefix(rdeConfig.objectpath, name)) |
| { |
| BMCWEB_LOG_ERROR << " Failed to get a prefix for " |
| << rdeConfig.objectpath; |
| return; |
| } |
| BMCWEB_LOG_DEBUG << " Got prefix " << name; |
| } |
| std::string resultString; |
| auto result = rdeSatelliteInfo.emplace(name, std::move(rdeConfig)); |
| if (result.second) |
| { |
| resultString = "Added new RDE Device config "; |
| } |
| else |
| { |
| resultString = "Updated existing RDE Device config "; |
| } |
| } |
| |
| enum AggregationType : std::uint8_t |
| { |
| Collection, |
| ContainsSubordinate, |
| Resource, |
| }; |
| |
| static void |
| startAggregation(AggregationType aggType, const crow::Request& thisReq, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| if (thisReq.method() != boost::beast::http::verb::get) |
| { |
| if (aggType == AggregationType::Collection) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Only aggregate GET requests to top level collections"; |
| return; |
| } |
| |
| if (aggType == AggregationType::ContainsSubordinate) |
| { |
| BMCWEB_LOG_DEBUG << "Only aggregate GET requests when uptree of" |
| << " a top level collection"; |
| return; |
| } |
| } |
| |
| // Create a copy of thisReq so we we can still locally process the req |
| std::error_code ec; |
| auto localReq = std::make_shared<crow::Request>(thisReq.req, ec); |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "Failed to create copy of request"; |
| if (aggType == AggregationType::Resource) |
| { |
| messages::internalError(asyncResp->res); |
| } |
| return; |
| } |
| |
| // Strip query params that don't work correctly if forwarded |
| parameterRemove(*localReq); |
| |
| getSatelliteConfigs( |
| std::bind_front(aggregateAndHandle, aggType, localReq, asyncResp)); |
| } |
| |
| static void findSatellite( |
| const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo, |
| const std::unordered_map<std::string, RdeSatelliteConfig>& |
| rdeSatelliteInfo, |
| std::string_view memberName) |
| { |
| bool validPrefix = false; |
| // Determine if the resource ID begins with a known prefix |
| for (const auto& satellite : satelliteInfo) |
| { |
| std::string targetPrefix = satellite.first; |
| targetPrefix += "_"; |
| if (memberName.starts_with(targetPrefix)) |
| { |
| BMCWEB_LOG_DEBUG << "\"" << satellite.first |
| << "\" is a known prefix"; |
| |
| // Remove the known prefix from the request's URI and |
| // then forward to the associated satellite BMC |
| getInstance().forwardRequest(req, asyncResp, satellite.first, |
| satelliteInfo); |
| validPrefix = true; |
| } |
| } |
| // Determine if the resource ID begins with a known prefix |
| for (const auto& rdeSatellite : rdeSatelliteInfo) |
| { |
| std::string targetPrefix = rdeSatellite.first; |
| targetPrefix += "_"; |
| if (memberName.starts_with(targetPrefix)) |
| { |
| BMCWEB_LOG_DEBUG << "\"" << rdeSatellite.first |
| << "\" is a known prefix"; |
| // Remove the known prefix from the request's URI and |
| // then forward to RDE Daemon |
| forwardRdeRequest(req, asyncResp, rdeSatellite.first, |
| rdeSatelliteInfo); |
| validPrefix = true; |
| } |
| } |
| if (validPrefix) |
| { |
| return; |
| } |
| // We didn't recognize the prefix and need to return a 404 |
| std::string nameStr = req.url().segments().back(); |
| messages::resourceNotFound(asyncResp->res, "", nameStr); |
| } |
| |
| // Intended to handle an incoming request based on if Redfish Aggregation |
| // is enabled. Forwards request to satellite BMC if it exists. |
| static void aggregateAndHandle( |
| AggregationType aggType, |
| const std::shared_ptr<crow::Request>& sharedReq, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const boost::system::error_code& ec, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo, |
| const std::unordered_map<std::string, RdeSatelliteConfig>& |
| rdeSatelliteInfo) |
| { |
| if (sharedReq == nullptr) |
| { |
| return; |
| } |
| // Something went wrong while querying dbus |
| if (ec) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // No satellite or RDE configs means we don't need to keep attempting to |
| // aggregate |
| if (satelliteInfo.empty() && rdeSatelliteInfo.empty()) |
| { |
| // For collections or resources that can contain a subordinate |
| // top level collection we'll also handle the request locally so we |
| // don't need to write an error code |
| if (aggType == AggregationType::Resource) |
| { |
| std::string nameStr = sharedReq->url().segments().back(); |
| messages::resourceNotFound(asyncResp->res, "", nameStr); |
| } |
| return; |
| } |
| |
| const crow::Request& thisReq = *sharedReq; |
| if constexpr (enablePlatform9) |
| { |
| BMCWEB_LOG_DEBUG << "Aggregation is enabled, begin processing of " |
| << thisReq.url(); |
| } |
| else |
| { |
| BMCWEB_LOG_DEBUG << "Aggregation is enabled, begin processing of " |
| << thisReq.target(); |
| } |
| |
| // We previously determined the request is for a collection. No need to |
| // check again |
| if (aggType == AggregationType::Collection) |
| { |
| BMCWEB_LOG_DEBUG << "Aggregating a collection"; |
| // We need to use a specific response handler and send the |
| // request to all known satellites |
| getInstance().forwardCollectionRequests( |
| thisReq, asyncResp, satelliteInfo, rdeSatelliteInfo); |
| return; |
| } |
| |
| // We previously determined the request may contain a subordinate |
| // collection. No need to check again |
| if (aggType == AggregationType::ContainsSubordinate) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Aggregating what may have a subordinate collection"; |
| // We need to use a specific response handler and send the |
| // request to all known satellites |
| getInstance().forwardContainsSubordinateRequests(thisReq, asyncResp, |
| satelliteInfo); |
| return; |
| } |
| |
| const boost::urls::segments_view urlSegments = thisReq.url().segments(); |
| boost::urls::url currentUrl("/"); |
| boost::urls::segments_view::iterator it = urlSegments.begin(); |
| const boost::urls::segments_view::const_iterator end = |
| urlSegments.end(); |
| |
| // Skip past the leading "/redfish/v1" |
| it++; |
| it++; |
| for (; it != end; it++) |
| { |
| if (std::binary_search(topCollections.begin(), topCollections.end(), |
| currentUrl.buffer())) |
| { |
| // We've matched a resource collection so this current segment |
| // must contain an aggregation prefix |
| findSatellite(thisReq, asyncResp, satelliteInfo, |
| rdeSatelliteInfo, *it); |
| return; |
| } |
| |
| currentUrl.segments().push_back(*it); |
| } |
| |
| // We shouldn't reach this point since we should've hit one of the |
| // previous exits |
| messages::internalError(asyncResp->res); |
| } |
| |
| // Attempt to forward a request to the satellite BMC associated with the |
| // prefix. |
| void forwardRequest( |
| const crow::Request& thisReq, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& prefix, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo) |
| { |
| const auto& sat = satelliteInfo.find(prefix); |
| if (sat == satelliteInfo.end()) |
| { |
| // Realistically this shouldn't get called since we perform an |
| // earlier check to make sure the prefix exists |
| BMCWEB_LOG_ERROR << "Unrecognized satellite prefix \"" << prefix |
| << "\""; |
| return; |
| } |
| |
| // We need to strip the prefix from the request's path |
| std::string targetURI; |
| if constexpr (enablePlatform9) |
| { |
| targetURI = std::string(thisReq.url().path()); |
| } |
| else |
| { |
| targetURI = std::string(thisReq.target()); |
| } |
| |
| size_t pos = targetURI.find(prefix + "_"); |
| if (pos == std::string::npos) |
| { |
| // If this fails then something went wrong |
| BMCWEB_LOG_ERROR << "Error removing prefix \"" << prefix |
| << "_\" from request URI"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| targetURI.erase(pos, prefix.size() + 1); |
| |
| std::function<void(crow::Response&)> cb = |
| std::bind_front(processResponse, prefix, asyncResp); |
| |
| std::string data = thisReq.req.body(); |
| client.sendDataWithCallback(data, std::string(sat->second.host()), |
| sat->second.port_number(), targetURI, |
| false /*useSSL*/, thisReq.fields(), |
| thisReq.method(), cb); |
| } |
| |
| // Forward a request for a collection URI to each known satellite BMC |
| void forwardCollectionRequests( |
| const crow::Request& thisReq, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo, |
| const std::unordered_map<std::string, RdeSatelliteConfig>& |
| rdeSatelliteInfo) |
| { |
| for (const auto& sat : satelliteInfo) |
| { |
| std::function<void(crow::Response&)> cb = std::bind_front( |
| processCollectionResponse, sat.first, asyncResp); |
| |
| std::string targetURI; |
| if constexpr (enablePlatform9) |
| { |
| targetURI = std::string(thisReq.url().path()); |
| } |
| else |
| { |
| targetURI = std::string(thisReq.target()); |
| } |
| std::string data = thisReq.req.body(); |
| client.sendDataWithCallback(data, std::string(sat.second.host()), |
| sat.second.port_number(), targetURI, |
| false /*useSSL*/, thisReq.fields(), |
| thisReq.method(), cb); |
| } |
| for (const auto& rsat : rdeSatelliteInfo) |
| { |
| |
| uint8_t operationId = 1; |
| std::string requestPayload; |
| BMCWEB_LOG_DEBUG << " Collection Request: dbus call to RDE Daemon " |
| << " operationId " << operationId; |
| std::string targetURI(thisReq.target()); |
| if (managedStore::RequestStatsStore::isRdeRateLimitEnabled() && |
| managedStore::RequestStatsStore::instance() |
| .getCurrentRdeRequestSkips() > 0) |
| { |
| BMCWEB_LOG_DEBUG << " Skipping the request " << targetURI; |
| asyncResp->requestStatsContext->updateRdeSkips(); |
| managedStore::RequestStatsStore::instance() |
| .updateCurrentRdeRequestSkips(); |
| return; |
| } |
| BMCWEB_LOG_DEBUG << "Collections objpath " << rsat.second.objectpath |
| << " targetURI " << targetURI << " udevid " |
| << rsat.second.udevid; |
| asyncResp->res.startTimetrace(rsat.first); |
| if (managedStore::RequestStatsStore::isRdeRateLimitEnabled()) |
| { |
| asyncResp->requestStatsContext->updateRdeReqs(); |
| } |
| managedStore::GetManagedObjectStore()->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| [&operationId, rsat, |
| asyncResp](const boost::system::error_code ec, |
| const std::string& jsonString) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error operationId " |
| << operationId << " , " << ec.value() |
| << ", " << ec.message(); |
| if (managedStore::RequestStatsStore:: |
| isRdeRateLimitEnabled()) |
| { |
| asyncResp->requestStatsContext->updateRdeDbusErrors(); |
| managedStore::RequestStatsStore::instance() |
| .updateCurrentRdeDbusErrors(); |
| if (managedStore::RequestStatsStore::instance() |
| .getCurrentRdeDbusErrors() > |
| managedStore::RequestStatsStore:: |
| rdeErrorThreshold() && |
| managedStore::RequestStatsStore::instance() |
| .getCurrentRdeRequestSkips() <= 0) |
| { |
| |
| BMCWEB_LOG_ERROR << "RDE Rate Limit enabled"; |
| asyncResp->requestStatsContext |
| ->updateRdeRateLimitToggles(); |
| managedStore::RequestStatsStore::instance() |
| .setCurrentRdeRequestSkips( |
| managedStore::RequestStatsStore:: |
| rdeMaxSkips()); |
| } |
| } |
| return; |
| } |
| if (managedStore::RequestStatsStore::isRdeRateLimitEnabled()) |
| { |
| managedStore::RequestStatsStore::instance() |
| .setCurrentRdeDbusErrors(0); |
| managedStore::RequestStatsStore::instance() |
| .setCurrentRdeRequestSkips(0); |
| } |
| processRdeCollectionResponse(rsat.first, asyncResp, jsonString); |
| }, |
| "xyz.openbmc_project.rdeoperation", rsat.second.objectpath, |
| "xyz.openbmc_project.RdeDevice", "execute_rde", |
| generateRandomInt(), operationId, targetURI, rsat.second.udevid, |
| requestPayload); |
| } |
| } |
| |
| // Forward request for a URI that is uptree of a top level collection to |
| // each known satellite BMC |
| void forwardContainsSubordinateRequests( |
| const crow::Request& thisReq, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo) |
| { |
| for (const auto& sat : satelliteInfo) |
| { |
| std::function<void(crow::Response&)> cb = std::bind_front( |
| processContainsSubordinateResponse, sat.first, asyncResp); |
| |
| std::string targetURI(thisReq.target()); |
| std::string data = thisReq.req.body(); |
| client.sendDataWithCallback(data, std::string(sat.second.host()), |
| sat.second.port_number(), targetURI, |
| false /*useSSL*/, thisReq.fields(), |
| thisReq.method(), cb); |
| } |
| } |
| |
| // Attempt to forward a request to the RDE Daemon associated with the |
| // prefix. |
| static void forwardRdeRequest( |
| const crow::Request& thisReq, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& prefix, |
| const std::unordered_map<std::string, RdeSatelliteConfig>& |
| rdeSatelliteInfo) |
| { |
| const auto& sat = rdeSatelliteInfo.find(prefix); |
| if (sat == rdeSatelliteInfo.end()) |
| { |
| // Realistically this shouldn't get called since we perform an |
| // earlier check to make sure the prefix exists |
| BMCWEB_LOG_ERROR << "Unrecognized RDE Device prefix \"" << prefix |
| << "\""; |
| return; |
| } |
| |
| // We need to strip the prefix from the request's path |
| std::string targetURI(thisReq.target()); |
| if (managedStore::RequestStatsStore::isRdeRateLimitEnabled() && |
| managedStore::RequestStatsStore::instance() |
| .getCurrentRdeRequestSkips() > 0) |
| { |
| BMCWEB_LOG_DEBUG << " Skipping the request " << targetURI; |
| asyncResp->requestStatsContext->updateRdeSkips(); |
| managedStore::RequestStatsStore::instance() |
| .updateCurrentRdeRequestSkips(); |
| return; |
| } |
| size_t pos = targetURI.find(prefix + "_"); |
| if (pos == std::string::npos) |
| { |
| // If this fails then something went wrong |
| BMCWEB_LOG_ERROR << "Error removing prefix \"" << prefix |
| << "_\" from request URI"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| targetURI.erase(pos, prefix.size() + 1); |
| |
| uint8_t operationId = 1; |
| std::string requestPayload; |
| boost::beast::http::verb method = thisReq.method(); |
| if (thisReq.method() == boost::beast::http::verb::post) |
| { |
| operationId = 8; |
| requestPayload = thisReq.body(); |
| } |
| else if (thisReq.method() == boost::beast::http::verb::patch) |
| { |
| operationId = 4; |
| requestPayload = thisReq.body(); |
| } |
| BMCWEB_LOG_DEBUG |
| << " Resource Request: dbus call to RDE Daemon operationId " |
| << operationId; |
| BMCWEB_LOG_DEBUG << "objpath " << sat->second.objectpath |
| << " targetURI " << targetURI << " udevid " |
| << sat->second.udevid << " method " << method; |
| asyncResp->res.startTimetrace(prefix); |
| if (managedStore::RequestStatsStore::isRdeRateLimitEnabled()) |
| { |
| asyncResp->requestStatsContext->updateRdeReqs(); |
| } |
| managedStore::GetManagedObjectStore()->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| [&operationId, method, prefix, |
| asyncResp](const boost::system::error_code ec, |
| const std::string& jsonString) { |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error operationId " |
| << operationId << " , " << ec.value() << ", " |
| << ec.message(); |
| if (managedStore::RequestStatsStore::isRdeRateLimitEnabled()) |
| |
| { |
| asyncResp->requestStatsContext->updateRdeDbusErrors(); |
| managedStore::RequestStatsStore::instance() |
| .updateCurrentRdeDbusErrors(); |
| |
| if (managedStore::RequestStatsStore::instance() |
| .getCurrentRdeDbusErrors() > |
| managedStore::RequestStatsStore:: |
| rdeErrorThreshold() && |
| managedStore::RequestStatsStore::instance() |
| .getCurrentRdeRequestSkips() <= 0) |
| { |
| BMCWEB_LOG_ERROR << "RDE Rate limiting enabled"; |
| asyncResp->requestStatsContext |
| ->updateRdeRateLimitToggles(); |
| managedStore::RequestStatsStore::instance() |
| .setCurrentRdeRequestSkips( |
| managedStore::RequestStatsStore::rdeMaxSkips()); |
| } |
| } |
| return; |
| } |
| if (managedStore::RequestStatsStore::isRdeRateLimitEnabled()) |
| { |
| managedStore::RequestStatsStore::instance() |
| .setCurrentRdeDbusErrors(0); |
| managedStore::RequestStatsStore::instance() |
| .setCurrentRdeRequestSkips(0); |
| } |
| processRdeResponse(prefix, method, asyncResp, jsonString); |
| }, |
| "xyz.openbmc_project.rdeoperation", sat->second.objectpath, |
| "xyz.openbmc_project.RdeDevice", "execute_rde", generateRandomInt(), |
| operationId, targetURI, sat->second.udevid, requestPayload); |
| } |
| // Processes the response returned by a RDE Device and loads its |
| // contents into asyncResp |
| static void |
| processRdeResponse(std::string_view prefix, |
| boost::beast::http::verb method, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& respString) |
| { |
| |
| nlohmann::json jsonVal = |
| nlohmann::json::parse(respString, nullptr, false); |
| if (jsonVal.is_discarded()) |
| { |
| BMCWEB_LOG_ERROR << "Error parsing RDE Device response as JSON " |
| << respString; |
| messages::operationFailed(asyncResp->res); |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Successfully parsed RDE Device response"; |
| |
| if (method == boost::beast::http::verb::post) |
| { |
| if (jsonVal["Status"] == "Completed") |
| { |
| asyncResp->res.result(200); |
| } |
| else |
| { |
| messages::operationFailed(asyncResp->res); |
| } |
| return; |
| } |
| // TODO: For collections we want to add the satellite responses to |
| // our response rather than just straight overwriting them if our |
| // local handling was successful (i.e. would return a 200). |
| addPrefixes(jsonVal, prefix); |
| |
| if constexpr (bmcwebEnableRdeDevice) |
| { |
| if (jsonVal.contains( |
| "/Location/PartLocation/ServiceLabel"_json_pointer)) |
| { |
| BMCWEB_LOG_DEBUG << " @odata.type " << jsonVal["@odata.type"]; |
| if (jsonVal["Model"] == platform6Chassis1 || |
| jsonVal["Model"] == platform6Chassis2) |
| { |
| BMCWEB_LOG_DEBUG << "Setting up service label " |
| << rdeServiceLabelMap[std::string{prefix}] |
| << " for prefix " << prefix; |
| jsonVal["Location"]["PartLocation"]["ServiceLabel"] = |
| rdeServiceLabelMap[std::string{prefix}]; |
| } |
| } |
| auto it = jsonVal.find("Id"); |
| if (it != jsonVal.end() && it->is_string()) |
| { |
| std::string* id_ptr = it->get_ptr<std::string*>(); |
| if (id_ptr != nullptr) |
| { |
| id_ptr->insert(0, std::string(prefix) + "_"); |
| } |
| } |
| } |
| |
| asyncResp->res.result(200); |
| asyncResp->res.jsonValue = std::move(jsonVal); |
| asyncResp->res.endTimetrace(std::string(prefix)); |
| |
| BMCWEB_LOG_DEBUG << "Finished writing asyncResp"; |
| } |
| |
| // Processes the collection response returned by a RDE Device and merges |
| // its "@odata.id" values |
| static void processRdeCollectionResponse( |
| const std::string& prefix, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& respString) |
| { |
| nlohmann::json jsonVal = |
| nlohmann::json::parse(respString, nullptr, false); |
| if (jsonVal.is_discarded()) |
| { |
| BMCWEB_LOG_ERROR << "Error parsing RDEd response as JSON " |
| << respString; |
| |
| // Notify the user if doing so won't overwrite a valid response |
| if ((asyncResp->res.resultInt() != 200) && |
| (asyncResp->res.resultInt() != 502)) |
| { |
| messages::operationFailed(asyncResp->res); |
| } |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Successfully parsed RDEd response"; |
| |
| // Now we need to add the prefix to the URIs contained in the |
| // response. |
| addPrefixes(jsonVal, prefix); |
| |
| BMCWEB_LOG_DEBUG << "Added prefix to parsed RDE Device response"; |
| |
| // If this resource collection does not exist on the aggregating bmc |
| // and has not already been added from processing the response from |
| // a different satellite then we need to completely overwrite |
| // asyncResp |
| if (asyncResp->res.resultInt() != 200) |
| { |
| // We only want to aggregate collections that contain a |
| // "Members" array |
| if ((!jsonVal.contains("Members")) && |
| (!jsonVal["Members"].is_array())) |
| { |
| BMCWEB_LOG_DEBUG << "Skipping aggregating unsupported resource"; |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG |
| << "Collection does not exist, overwriting asyncResp"; |
| asyncResp->res.jsonValue = std::move(jsonVal); |
| |
| BMCWEB_LOG_DEBUG << "Finished overwriting asyncResp"; |
| } |
| else |
| { |
| // We only want to aggregate collections that contain a |
| // "Members" array |
| if ((!asyncResp->res.jsonValue.contains("Members")) && |
| (!asyncResp->res.jsonValue["Members"].is_array())) |
| |
| { |
| BMCWEB_LOG_DEBUG << "Skipping aggregating unsupported resource"; |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Adding aggregated resources from \"" << prefix |
| << "\" to collection"; |
| |
| // TODO: This is a potential race condition with multiple |
| // satellites and the aggregating bmc attempting to write to |
| // update this array. May need to cascade calls to the next |
| // satellite at the end of this function. |
| auto& members = asyncResp->res.jsonValue["Members"]; |
| auto& satMembers = jsonVal["Members"]; |
| for (auto& satMem : satMembers) |
| { |
| members.push_back(std::move(satMem)); |
| } |
| asyncResp->res.jsonValue["Members@odata.count"] = members.size(); |
| |
| // TODO: Do we need to sort() after updating the array? |
| } |
| asyncResp->res.endTimetrace(prefix); |
| } // End processRdeCollectionResponse() |
| |
| public: |
| RedfishAggregator(const RedfishAggregator&) = delete; |
| RedfishAggregator& operator=(const RedfishAggregator&) = delete; |
| RedfishAggregator(RedfishAggregator&&) = delete; |
| RedfishAggregator& operator=(RedfishAggregator&&) = delete; |
| ~RedfishAggregator() = default; |
| |
| static RedfishAggregator& getInstance() |
| { |
| static RedfishAggregator handler; |
| return handler; |
| } |
| |
| // Polls D-Bus to get all available satellite config information |
| // Expects a handler which interacts with the returned configs |
| static void getSatelliteConfigs( |
| std::function< |
| void(const boost::system::error_code&, |
| const std::unordered_map<std::string, boost::urls::url>&, |
| const std::unordered_map<std::string, RdeSatelliteConfig>&)> |
| handler) |
| { |
| BMCWEB_LOG_DEBUG << "Gathering satellite configs"; |
| |
| managedStore::ManagedObjectStoreContext context(nullptr); |
| managedStore::GetManagedObjectStore()->getManagedObjectsWithContext( |
| "xyz.openbmc_project.EntityManager", |
| {"/xyz/openbmc_project/inventory"}, |
| context, |
| [handler{std::move(handler)}]( |
| const boost::system::error_code& ec, |
| const dbus::utility::ManagedObjectType& objects) { |
| std::unordered_map<std::string, boost::urls::url> satelliteInfo; |
| std::unordered_map<std::string, RdeSatelliteConfig> |
| rdeSatelliteInfo; |
| if (ec) |
| { |
| BMCWEB_LOG_ERROR << "DBUS response error " << ec.value() << ", " |
| << ec.message(); |
| handler(ec, satelliteInfo, rdeSatelliteInfo); |
| return; |
| } |
| |
| // Maps a chosen alias representing a satellite BMC to a url |
| // containing the information required to create a http |
| // connection to the satellite |
| findSatelliteConfigs(objects, satelliteInfo, rdeSatelliteInfo); |
| |
| if (!satelliteInfo.empty()) |
| { |
| BMCWEB_LOG_DEBUG << "Redfish Aggregation enabled with " |
| << std::to_string(satelliteInfo.size()) |
| << " satellite BMCs"; |
| } |
| else if (!rdeSatelliteInfo.empty()) |
| { |
| BMCWEB_LOG_DEBUG << "Redfish Aggregation enabled with " |
| << std::to_string(rdeSatelliteInfo.size()) |
| << " RDE Device"; |
| } |
| else |
| { |
| BMCWEB_LOG_DEBUG |
| << "No satellite BMCs detected. Redfish Aggregation not enabled"; |
| } |
| handler(ec, satelliteInfo, rdeSatelliteInfo); |
| }); |
| } |
| |
| // Processes the response returned by a satellite BMC and loads its |
| // contents into asyncResp |
| static void |
| processResponse(std::string_view prefix, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| crow::Response& resp) |
| { |
| // 429 and 502 mean we didn't actually send the request so don't |
| // overwrite the response headers in that case |
| if ((resp.result() == boost::beast::http::status::too_many_requests) || |
| (resp.result() == boost::beast::http::status::bad_gateway)) |
| { |
| asyncResp->res.result(resp.result()); |
| return; |
| } |
| |
| // We want to attempt prefix fixing regardless of response code |
| // The resp will not have a json component |
| // We need to create a json from resp's stringResponse |
| std::string_view contentType = resp.getHeaderValue("Content-Type"); |
| if (boost::iequals(contentType, "application/json") || |
| boost::iequals(contentType, "application/json; charset=utf-8")) |
| { |
| nlohmann::json jsonVal = |
| nlohmann::json::parse(resp.body(), nullptr, false); |
| if (jsonVal.is_discarded()) |
| { |
| BMCWEB_LOG_ERROR << "Error parsing satellite response as JSON"; |
| messages::operationFailed(asyncResp->res); |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Successfully parsed satellite response"; |
| |
| addPrefixes(jsonVal, prefix); |
| |
| if constexpr (enablePlatform9) |
| { |
| // Hardcode relation to aggregating BMC |
| if ((jsonVal.contains("@odata.id")) && |
| (jsonVal["@odata.id"].is_string())) |
| { |
| std::string targetURI(jsonVal["@odata.id"]); |
| std::string aggRootURI(prefix); |
| aggRootURI = "/redfish/v1/Chassis/" + aggRootURI + "_" + |
| std::string(platform9Chassis5); |
| if (targetURI == aggRootURI) |
| { |
| jsonVal["Links"]["ContainedBy"] = { |
| {"@odata.id", "/redfish/v1/Chassis/" + |
| std::string(platform9Chassis4)}}; |
| } |
| } |
| // End hardcoded workaround |
| } |
| |
| BMCWEB_LOG_DEBUG << "Added prefix to parsed satellite response"; |
| |
| asyncResp->res.result(resp.result()); |
| asyncResp->res.jsonValue = std::move(jsonVal); |
| |
| BMCWEB_LOG_DEBUG << "Finished writing asyncResp"; |
| } |
| else |
| { |
| // We allow any Content-Type that is not "application/json" now |
| asyncResp->res.result(resp.result()); |
| asyncResp->res.write(resp.body()); |
| } |
| addAggregatedHeaders(asyncResp->res, resp, prefix); |
| } |
| |
| // Processes the collection response returned by a satellite BMC and merges |
| // its "@odata.id" values |
| static void processCollectionResponse( |
| const std::string& prefix, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| crow::Response& resp) |
| { |
| // 429 and 502 mean we didn't actually send the request so don't |
| // overwrite the response headers in that case |
| if ((resp.result() == boost::beast::http::status::too_many_requests) || |
| (resp.result() == boost::beast::http::status::bad_gateway)) |
| { |
| return; |
| } |
| |
| if (resp.resultInt() != 200) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Collection resource does not exist in satellite BMC \"" |
| << prefix << "\""; |
| // Return the error if we haven't had any successes |
| if (asyncResp->res.resultInt() != 200) |
| { |
| asyncResp->res.result(resp.result()); |
| asyncResp->res.write(resp.body()); |
| } |
| return; |
| } |
| |
| // The resp will not have a json component |
| // We need to create a json from resp's stringResponse |
| std::string_view contentType = resp.getHeaderValue("Content-Type"); |
| if (boost::iequals(contentType, "application/json") || |
| boost::iequals(contentType, "application/json; charset=utf-8")) |
| { |
| nlohmann::json jsonVal = |
| nlohmann::json::parse(resp.body(), nullptr, false); |
| if (jsonVal.is_discarded()) |
| { |
| BMCWEB_LOG_ERROR << "Error parsing satellite response as JSON"; |
| |
| // Notify the user if doing so won't overwrite a valid response |
| if (asyncResp->res.resultInt() != 200) |
| { |
| messages::operationFailed(asyncResp->res); |
| } |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Successfully parsed satellite response"; |
| |
| // Now we need to add the prefix to the URIs contained in the |
| // response. |
| addPrefixes(jsonVal, prefix); |
| |
| BMCWEB_LOG_DEBUG << "Added prefix to parsed satellite response"; |
| |
| // If this resource collection does not exist on the aggregating bmc |
| // and has not already been added from processing the response from |
| // a different satellite then we need to completely overwrite |
| // asyncResp |
| if (asyncResp->res.resultInt() != 200) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Collection does not exist, overwriting asyncResp"; |
| asyncResp->res.result(resp.result()); |
| asyncResp->res.jsonValue = std::move(jsonVal); |
| asyncResp->res.addHeader("Content-Type", "application/json"); |
| |
| BMCWEB_LOG_DEBUG << "Finished overwriting asyncResp"; |
| } |
| else |
| { |
| BMCWEB_LOG_DEBUG << "Adding aggregated resources from \"" |
| << prefix << "\" to collection"; |
| |
| // TODO: This is a potential race condition with multiple |
| // satellites and the aggregating bmc attempting to write to |
| // update this array. May need to cascade calls to the next |
| // satellite at the end of this function. |
| // This is presumably not a concern when there is only a single |
| // satellite since the aggregating bmc should have completed |
| // before the response is received from the satellite. |
| |
| auto& members = asyncResp->res.jsonValue["Members"]; |
| if (!members.is_array()) |
| { |
| // Satellite response is being processed before top level |
| // collection request has been locally handled so we need |
| // to create Members array |
| BMCWEB_LOG_DEBUG << "Created new Members array"; |
| members = nlohmann::json::array(); |
| } |
| auto& satMembers = jsonVal["Members"]; |
| for (auto& satMem : satMembers) |
| { |
| members.push_back(std::move(satMem)); |
| } |
| asyncResp->res.jsonValue["Members@odata.count"] = |
| members.size(); |
| |
| // TODO: Do we need to sort() after updating the array? |
| } |
| } |
| else |
| { |
| BMCWEB_LOG_ERROR << "Received unparsable response from \"" << prefix |
| << "\""; |
| // We received a response that was not a json. |
| // Notify the user only if we did not receive any valid responses |
| // and if the resource collection does not already exist on the |
| // aggregating BMC |
| if (asyncResp->res.resultInt() != 200) |
| { |
| messages::operationFailed(asyncResp->res); |
| } |
| } |
| } // End processCollectionResponse() |
| |
| // Processes the response returned by a satellite BMC and merges any |
| // properties whose "@odata.id" value is the URI or either a top level |
| // collection or is uptree from a top level collection |
| static void processContainsSubordinateResponse( |
| const std::string& prefix, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| crow::Response& resp) |
| { |
| // 429 and 502 mean we didn't actually send the request so don't |
| // overwrite the response headers in that case |
| if ((resp.result() == boost::beast::http::status::too_many_requests) || |
| (resp.result() == boost::beast::http::status::bad_gateway)) |
| { |
| return; |
| } |
| |
| if (resp.resultInt() != 200) |
| { |
| BMCWEB_LOG_DEBUG |
| << "Resource uptree from Collection does not exist in " |
| << "satellite BMC \"" << prefix << "\""; |
| // Return the error if we haven't had any successes |
| if (asyncResp->res.resultInt() != 200) |
| { |
| asyncResp->res.result(resp.result()); |
| asyncResp->res.write(resp.body()); |
| } |
| return; |
| } |
| |
| // The resp will not have a json component |
| // We need to create a json from resp's stringResponse |
| std::string_view contentType = resp.getHeaderValue("Content-Type"); |
| if (boost::iequals(contentType, "application/json") || |
| boost::iequals(contentType, "application/json; charset=utf-8")) |
| { |
| bool addedLinks = false; |
| nlohmann::json jsonVal = |
| nlohmann::json::parse(resp.body(), nullptr, false); |
| if (jsonVal.is_discarded()) |
| { |
| BMCWEB_LOG_ERROR << "Error parsing satellite response as JSON"; |
| |
| // Notify the user if doing so won't overwrite a valid response |
| if (asyncResp->res.resultInt() != 200) |
| { |
| messages::operationFailed(asyncResp->res); |
| } |
| return; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Successfully parsed satellite response"; |
| |
| // Parse response and add properties missing from the AsyncResp |
| // Valid properties will be of the form <property>.@odata.id and |
| // @odata.id is a <URI>. In other words, the json should contain |
| // multiple properties such that |
| // {"<property>":{"@odata.id": "<URI>"}} |
| nlohmann::json::object_t* object = |
| jsonVal.get_ptr<nlohmann::json::object_t*>(); |
| if (object == nullptr) |
| { |
| BMCWEB_LOG_ERROR << "Parsed JSON was not an object?"; |
| return; |
| } |
| |
| for (std::pair<const std::string, nlohmann::json>& prop : *object) |
| { |
| if (!prop.second.contains("@odata.id")) |
| { |
| continue; |
| } |
| |
| std::string* strValue = |
| prop.second["@odata.id"].get_ptr<std::string*>(); |
| if (strValue == nullptr) |
| { |
| BMCWEB_LOG_CRITICAL << "Field wasn't a string????"; |
| continue; |
| } |
| if (!searchCollectionsArray(*strValue, SearchType::CollOrCon)) |
| { |
| continue; |
| } |
| |
| addedLinks = true; |
| if (!asyncResp->res.jsonValue.contains(prop.first)) |
| { |
| // Only add the property if it did not already exist |
| BMCWEB_LOG_DEBUG << "Adding link for " << *strValue |
| << " from BMC " << prefix; |
| asyncResp->res.jsonValue[prop.first]["@odata.id"] = |
| *strValue; |
| continue; |
| } |
| } |
| |
| // If we added links to a previously unsuccessful (non-200) response |
| // then we need to make sure the response contains the bare minimum |
| // amount of additional information that we'd expect to have been |
| // populated. |
| if (addedLinks && (asyncResp->res.resultInt() != 200)) |
| { |
| // This resource didn't locally exist or an error |
| // occurred while generating the response. Remove any |
| // error messages and update the error code. |
| asyncResp->res.jsonValue.erase( |
| asyncResp->res.jsonValue.find("error")); |
| asyncResp->res.result(resp.result()); |
| |
| const auto& it1 = object->find("@odata.id"); |
| if (it1 != object->end()) |
| { |
| asyncResp->res.jsonValue["@odata.id"] = (it1->second); |
| } |
| const auto& it2 = object->find("@odata.type"); |
| if (it2 != object->end()) |
| { |
| asyncResp->res.jsonValue["@odata.type"] = (it2->second); |
| } |
| const auto& it3 = object->find("Id"); |
| if (it3 != object->end()) |
| { |
| asyncResp->res.jsonValue["Id"] = (it3->second); |
| } |
| const auto& it4 = object->find("Name"); |
| if (it4 != object->end()) |
| { |
| asyncResp->res.jsonValue["Name"] = (it4->second); |
| } |
| } |
| } |
| else |
| { |
| BMCWEB_LOG_ERROR << "Received unparsable response from \"" << prefix |
| << "\""; |
| // We received as response that was not a json |
| // Notify the user only if we did not receive any valid responses, |
| // and if the resource does not already exist on the aggregating BMC |
| if (asyncResp->res.resultInt() != 200) |
| { |
| messages::operationFailed(asyncResp->res); |
| } |
| } |
| } |
| |
| // Entry point to Redfish Aggregation |
| // Returns Result stating whether or not we still need to locally handle the |
| // request |
| static Result |
| beginAggregation(const crow::Request& thisReq, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| using crow::utility::OrMorePaths; |
| using crow::utility::readUrlSegments; |
| const boost::urls::url_view url = thisReq.url(); |
| |
| // We don't need to aggregate JsonSchemas due to potential issues such |
| // as version mismatches between aggregator and satellite BMCs. For |
| // now assume that the aggregator has all the schemas and versions that |
| // the aggregated server has. |
| if (crow::utility::readUrlSegments(url, "redfish", "v1", "JsonSchemas", |
| crow::utility::OrMorePaths())) |
| { |
| return Result::LocalHandle; |
| } |
| |
| // The first two segments should be "/redfish/v1". We need to check |
| // that before we can search topCollections |
| if (!crow::utility::readUrlSegments(url, "redfish", "v1", |
| crow::utility::OrMorePaths())) |
| { |
| return Result::LocalHandle; |
| } |
| |
| // Parse the URI to see if it begins with a known top level collection |
| // such as: |
| // /redfish/v1/Chassis |
| // /redfish/v1/UpdateService/FirmwareInventory |
| const boost::urls::segments_view urlSegments = url.segments(); |
| boost::urls::url currentUrl("/"); |
| boost::urls::segments_view::iterator it = urlSegments.begin(); |
| const boost::urls::segments_view::const_iterator end = |
| urlSegments.end(); |
| |
| // Skip past the leading "/redfish/v1" |
| it++; |
| it++; |
| for (; it != end; it++) |
| { |
| const std::string& collectionItem = *it; |
| if (std::binary_search(topCollections.begin(), topCollections.end(), |
| currentUrl.buffer())) |
| { |
| // We've matched a resource collection so this current segment |
| // might contain an aggregation prefix |
| // TODO: This needs to be rethought when we can support multiple |
| // satellites due to |
| // /redfish/v1/AggregationService/AggregationSources/5B247A |
| // being a local resource describing the satellite |
| if (collectionItem.starts_with("5B247A_") || |
| isMemberStartsWithKnownPrefix(collectionItem)) |
| { |
| BMCWEB_LOG_DEBUG << "Need to forward a request"; |
| |
| // Extract the prefix from the request's URI, retrieve the |
| // associated satellite config information, and then forward |
| // the request to that satellite. |
| startAggregation(AggregationType::Resource, thisReq, |
| asyncResp); |
| return Result::NoLocalHandle; |
| } |
| |
| // Handle collection URI with a trailing backslash |
| // e.g. /redfish/v1/Chassis/ |
| it++; |
| if ((it == end) && collectionItem.empty()) |
| { |
| startAggregation(AggregationType::Collection, thisReq, |
| asyncResp); |
| } |
| |
| // We didn't recognize the prefix or it's a collection with a |
| // trailing "/". In both cases we still want to locally handle |
| // the request |
| return Result::LocalHandle; |
| } |
| |
| currentUrl.segments().push_back(collectionItem); |
| } |
| |
| // If we made it here then currentUrl could contain a top level |
| // collection URI without a trailing "/", e.g. /redfish/v1/Chassis |
| if (std::binary_search(topCollections.begin(), topCollections.end(), |
| currentUrl.buffer())) |
| { |
| startAggregation(AggregationType::Collection, thisReq, asyncResp); |
| return Result::LocalHandle; |
| } |
| |
| // If nothing else then the request could be for a resource which has a |
| // top level collection as a subordinate |
| if (searchCollectionsArray(url.buffer(), |
| SearchType::ContainsSubordinate)) |
| { |
| startAggregation(AggregationType::ContainsSubordinate, thisReq, |
| asyncResp); |
| return Result::LocalHandle; |
| } |
| |
| BMCWEB_LOG_DEBUG << "Aggregation not required"; |
| return Result::LocalHandle; |
| } |
| }; |
| |
| } // namespace redfish |
