| // SPDX-License-Identifier: Apache-2.0 |
| // SPDX-FileCopyrightText: Copyright OpenBMC Authors |
| #pragma once |
| |
| #include "app.hpp" |
| #include "async_resp.hpp" |
| #include "error_messages.hpp" |
| #include "http_request.hpp" |
| #include "http_response.hpp" |
| #include "logging.hpp" |
| #include "ossl_random.hpp" |
| #include "query.hpp" |
| #include "redfish_aggregator.hpp" |
| #include "registries/privilege_registry.hpp" |
| #include "utility.hpp" |
| #include "utils/json_utils.hpp" |
| |
| #include <boost/beast/http/field.hpp> |
| #include <boost/beast/http/verb.hpp> |
| #include <boost/system/result.hpp> |
| #include <boost/url/format.hpp> |
| #include <boost/url/parse.hpp> |
| #include <boost/url/url.hpp> |
| #include <nlohmann/json.hpp> |
| |
| #include <cstddef> |
| #include <functional> |
| #include <memory> |
| #include <unordered_map> |
| #include <utility> |
| |
| namespace redfish |
| { |
| |
| inline void handleAggregationServiceHead( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/AggregationService/AggregationService.json>; rel=describedby"); |
| } |
| |
| inline void handleAggregationServiceGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/AggregationService/AggregationService.json>; rel=describedby"); |
| nlohmann::json& json = asyncResp->res.jsonValue; |
| json["@odata.id"] = "/redfish/v1/AggregationService"; |
| json["@odata.type"] = "#AggregationService.v1_0_1.AggregationService"; |
| json["Id"] = "AggregationService"; |
| json["Name"] = "Aggregation Service"; |
| json["Description"] = "Aggregation Service"; |
| json["ServiceEnabled"] = true; |
| json["AggregationSources"]["@odata.id"] = |
| "/redfish/v1/AggregationService/AggregationSources"; |
| } |
| |
| inline void requestRoutesAggregationService(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/AggregationService/") |
| .privileges(redfish::privileges::headAggregationService) |
| .methods(boost::beast::http::verb::head)( |
| std::bind_front(handleAggregationServiceHead, std::ref(app))); |
| BMCWEB_ROUTE(app, "/redfish/v1/AggregationService/") |
| .privileges(redfish::privileges::getAggregationService) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleAggregationServiceGet, std::ref(app))); |
| } |
| |
| inline void populateAggregationSourceCollection( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const boost::system::error_code& ec, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo) |
| { |
| // Something went wrong while querying dbus |
| if (ec) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| nlohmann::json::array_t members; |
| for (const auto& sat : satelliteInfo) |
| { |
| nlohmann::json::object_t member; |
| member["@odata.id"] = boost::urls::format( |
| "/redfish/v1/AggregationService/AggregationSources/{}", sat.first); |
| members.emplace_back(std::move(member)); |
| } |
| asyncResp->res.jsonValue["Members@odata.count"] = members.size(); |
| asyncResp->res.jsonValue["Members"] = std::move(members); |
| } |
| |
| inline void handleAggregationSourceCollectionGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/AggregationSourceCollection/AggregationSourceCollection.json>; rel=describedby"); |
| nlohmann::json& json = asyncResp->res.jsonValue; |
| json["@odata.id"] = "/redfish/v1/AggregationService/AggregationSources"; |
| json["@odata.type"] = |
| "#AggregationSourceCollection.AggregationSourceCollection"; |
| json["Name"] = "Aggregation Source Collection"; |
| |
| // Query D-Bus for satellite configs and add them to the Members array |
| RedfishAggregator::getInstance().getSatelliteConfigs( |
| std::bind_front(populateAggregationSourceCollection, asyncResp)); |
| } |
| |
| inline void handleAggregationSourceCollectionHead( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/AggregationService/AggregationSourceCollection.json>; rel=describedby"); |
| } |
| |
| inline void requestRoutesAggregationSourceCollection(App& app) |
| { |
| BMCWEB_ROUTE(app, "/redfish/v1/AggregationService/AggregationSources/") |
| .privileges(redfish::privileges::getAggregationSourceCollection) |
| .methods(boost::beast::http::verb::get)(std::bind_front( |
| handleAggregationSourceCollectionGet, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, "/redfish/v1/AggregationService/AggregationSources/") |
| .privileges(redfish::privileges::getAggregationSourceCollection) |
| .methods(boost::beast::http::verb::head)(std::bind_front( |
| handleAggregationSourceCollectionHead, std::ref(app))); |
| } |
| |
| inline void populateAggregationSource( |
| const std::string& aggregationSourceId, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const boost::system::error_code& ec, |
| const std::unordered_map<std::string, boost::urls::url>& satelliteInfo) |
| { |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/AggregationSource/AggregationSource.json>; rel=describedby"); |
| |
| // Something went wrong while querying dbus |
| if (ec) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| const auto& sat = satelliteInfo.find(aggregationSourceId); |
| if (sat == satelliteInfo.end()) |
| { |
| messages::resourceNotFound(asyncResp->res, "AggregationSource", |
| aggregationSourceId); |
| return; |
| } |
| |
| asyncResp->res.jsonValue["@odata.id"] = boost::urls::format( |
| "/redfish/v1/AggregationService/AggregationSources/{}", |
| aggregationSourceId); |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#AggregationSource.v1_3_1.AggregationSource"; |
| asyncResp->res.jsonValue["Id"] = aggregationSourceId; |
| |
| // TODO: We may want to change this whenever we support aggregating multiple |
| // satellite BMCs. Otherwise all AggregationSource resources will have the |
| // same "Name". |
| // TODO: We should use the "Name" from the satellite config whenever we add |
| // support for including it in the data returned in satelliteInfo. |
| asyncResp->res.jsonValue["Name"] = "Aggregation source"; |
| std::string hostName(sat->second.encoded_origin()); |
| asyncResp->res.jsonValue["HostName"] = std::move(hostName); |
| |
| // Include UserName property, defaulting to null |
| auto& aggregator = RedfishAggregator::getInstance(); |
| auto it = aggregator.aggregationSources.find(aggregationSourceId); |
| if (it != aggregator.aggregationSources.end() && |
| !it->second.username.empty()) |
| { |
| asyncResp->res.jsonValue["UserName"] = it->second.username; |
| } |
| else |
| { |
| asyncResp->res.jsonValue["UserName"] = nullptr; |
| } |
| |
| // The Redfish spec requires Password to be null in responses |
| asyncResp->res.jsonValue["Password"] = nullptr; |
| } |
| |
| inline void handleAggregationSourceGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& aggregationSourceId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| |
| // Query D-Bus for satellite config corresponding to the specified |
| // AggregationSource |
| RedfishAggregator::getInstance().getSatelliteConfigs(std::bind_front( |
| populateAggregationSource, aggregationSourceId, asyncResp)); |
| } |
| |
| inline void handleAggregationSourceHead( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& aggregationSourceId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/AggregationService/AggregationSource.json>; rel=describedby"); |
| |
| // Needed to prevent unused variable error |
| BMCWEB_LOG_DEBUG("Added link header to response from {}", |
| aggregationSourceId); |
| } |
| |
| inline bool validateCredentialField(const std::optional<std::string>& field, |
| const std::string& fieldName, |
| crow::Response& res) |
| { |
| if (!field.has_value()) |
| { |
| return true; // Field not provided, that's okay |
| } |
| |
| if (field->empty()) |
| { |
| messages::stringValueTooShort(res, fieldName, "1"); |
| return false; |
| } |
| |
| if (field->find(':') != std::string::npos) |
| { |
| messages::propertyValueIncorrect(res, *field, fieldName); |
| return false; |
| } |
| |
| if (field->length() > 40) |
| { |
| messages::stringValueTooLong(res, fieldName, 40); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| inline void handleAggregationSourceCollectionPost( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| std::string hostname; |
| std::optional<std::string> username; |
| std::optional<std::string> password; |
| |
| if (!json_util::readJsonPatch(req, asyncResp->res, "HostName", hostname, |
| "UserName", username, "Password", password)) |
| { |
| return; |
| } |
| |
| boost::system::result<boost::urls::url> url = |
| boost::urls::parse_absolute_uri(hostname); |
| if (!url) |
| { |
| messages::propertyValueIncorrect(asyncResp->res, hostname, "HostName"); |
| return; |
| } |
| url->normalize(); |
| if (url->scheme() != "http" && url->scheme() != "https") |
| { |
| messages::propertyValueIncorrect(asyncResp->res, hostname, "HostName"); |
| return; |
| } |
| crow::utility::setPortDefaults(*url); |
| |
| // Check for duplicate hostname |
| auto& aggregator = RedfishAggregator::getInstance(); |
| for (const auto& [existingPrefix, existingSource] : |
| aggregator.aggregationSources) |
| { |
| if (existingSource.url == *url) |
| { |
| messages::resourceAlreadyExists(asyncResp->res, "AggregationSource", |
| "HostName", url->buffer()); |
| return; |
| } |
| } |
| |
| // Validate username and password |
| if (!validateCredentialField(username, "UserName", asyncResp->res)) |
| { |
| return; |
| } |
| if (!validateCredentialField(password, "Password", asyncResp->res)) |
| { |
| return; |
| } |
| |
| std::string prefix = bmcweb::getRandomIdOfLength(8); |
| aggregator.aggregationSources.emplace( |
| prefix, |
| AggregationSource{*url, username.value_or(""), password.value_or("")}); |
| |
| BMCWEB_LOG_DEBUG("Emplaced {} with url {}", prefix, url->buffer()); |
| asyncResp->res.addHeader( |
| boost::beast::http::field::location, |
| boost::urls::format("/redfish/v1/AggregationSources/{}", prefix) |
| .buffer()); |
| messages::created(asyncResp->res); |
| } |
| |
| inline void handleAggregationSourcePatch( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& aggregationSourceId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| |
| std::optional<std::string> username; |
| std::optional<std::string> password; |
| |
| if (!json_util::readJsonPatch(req, asyncResp->res, "UserName", username, |
| "Password", password)) |
| { |
| return; |
| } |
| |
| // Validate username and password |
| if (!validateCredentialField(username, "UserName", asyncResp->res)) |
| { |
| return; |
| } |
| if (!validateCredentialField(password, "Password", asyncResp->res)) |
| { |
| return; |
| } |
| |
| // Check if the aggregation source exists in writable sources |
| auto& aggregator = RedfishAggregator::getInstance(); |
| auto it = aggregator.aggregationSources.find(aggregationSourceId); |
| if (it != aggregator.aggregationSources.end()) |
| { |
| // Update only the fields that were provided |
| if (username.has_value()) |
| { |
| it->second.username = *username; |
| } |
| if (password.has_value()) |
| { |
| it->second.password = *password; |
| } |
| |
| messages::success(asyncResp->res); |
| return; |
| } |
| |
| // Not in writable sources, query D-Bus to check if it exists in |
| // Entity Manager sources |
| RedfishAggregator::getInstance().getSatelliteConfigs( |
| [asyncResp, aggregationSourceId]( |
| const boost::system::error_code& ec, |
| const std::unordered_map<std::string, boost::urls::url>& |
| satelliteInfo) { |
| // Something went wrong while querying dbus |
| if (ec) |
| { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| // Check if it exists in Entity Manager sources |
| if (satelliteInfo.contains(aggregationSourceId)) |
| { |
| // Source exists but is read-only (from Entity Manager) |
| messages::propertyNotWritable(asyncResp->res, "UserName"); |
| return; |
| } |
| |
| // Doesn't exist anywhere |
| messages::resourceNotFound(asyncResp->res, "AggregationSource", |
| aggregationSourceId); |
| }); |
| } |
| |
| inline void handleAggregationSourceDelete( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& aggregationSourceId) |
| { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
| { |
| return; |
| } |
| asyncResp->res.addHeader( |
| boost::beast::http::field::link, |
| "</redfish/v1/JsonSchemas/AggregationService/AggregationSource.json>; rel=describedby"); |
| |
| size_t deleted = RedfishAggregator::getInstance().aggregationSources.erase( |
| aggregationSourceId); |
| if (deleted == 0) |
| { |
| messages::resourceNotFound(asyncResp->res, "AggregationSource", |
| aggregationSourceId); |
| return; |
| } |
| |
| messages::success(asyncResp->res); |
| } |
| |
| inline void requestRoutesAggregationSource(App& app) |
| { |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/AggregationService/AggregationSources/<str>/") |
| .privileges(redfish::privileges::getAggregationSource) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleAggregationSourceGet, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/AggregationService/AggregationSources/<str>/") |
| .privileges(redfish::privileges::patchAggregationSource) |
| .methods(boost::beast::http::verb::patch)( |
| std::bind_front(handleAggregationSourcePatch, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/AggregationService/AggregationSources/<str>/") |
| .privileges(redfish::privileges::deleteAggregationSource) |
| .methods(boost::beast::http::verb::delete_)( |
| std::bind_front(handleAggregationSourceDelete, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/AggregationService/AggregationSources/<str>/") |
| .privileges(redfish::privileges::headAggregationSource) |
| .methods(boost::beast::http::verb::head)( |
| std::bind_front(handleAggregationSourceHead, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, "/redfish/v1/AggregationService/AggregationSources/") |
| .privileges(redfish::privileges::postAggregationSourceCollection) |
| .methods(boost::beast::http::verb::post)(std::bind_front( |
| handleAggregationSourceCollectionPost, std::ref(app))); |
| } |
| |
| } // namespace redfish |