| #ifndef THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_NVME_FEATURES_H_ |
| #define THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_NVME_FEATURES_H_ |
| |
| #include <systemd/sd-bus.h> |
| |
| #include <array> |
| #include <cstddef> |
| #include <cstdint> |
| #include <functional> |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <string_view> |
| #include <tuple> |
| #include <utility> |
| #include <variant> |
| #include <vector> |
| |
| #include "absl/functional/any_invocable.h" |
| #include "absl/status/status.h" |
| #include "absl/status/statusor.h" |
| #include "absl/strings/str_cat.h" |
| #include "boost/beast/http/verb.hpp" // NOLINT |
| #include "boost/system/error_code.hpp" // NOLINT |
| #include "app.hpp" |
| #include "http_request.hpp" |
| #include "http_response.hpp" |
| #include "logging.hpp" |
| #include "utility.hpp" |
| #include "async_resp.hpp" |
| #include "dbus_utility.hpp" |
| #include "error_messages.hpp" |
| #include "query.hpp" |
| #include "registries/privilege_registry.hpp" |
| #include "dbus_utils.hpp" |
| #include "json_utils.hpp" |
| #include "storage_utils.hpp" |
| #include "storage.hpp" |
| #include <nlohmann/json_fwd.hpp> |
| #include "managed_store.hpp" |
| #include "managed_store_types.hpp" |
| #include "sdbusplus/message.hpp" |
| #include "sdbusplus/message/native_types.hpp" |
| |
| namespace redfish { |
| |
| inline void processNvmeFeaturesCollectionGet( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& parentUri, const std::string& service, |
| const std::string& path) { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| dbus_utils::getProperty< |
| std::vector<std::tuple<std::string, std::string, std::string>>>( |
| service, path, "xyz.openbmc_project.NVMe.FeatureStore", |
| "FeatureCollection", context, |
| [asyncResp, parentUri]( |
| const boost::system::error_code& ec, |
| const std::vector<std::tuple<std::string, std::string, std::string>>& |
| features) { |
| if (ec) { |
| BMCWEB_LOG_ERROR << "Failed to get FeatureCollection: " << ec; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| nlohmann::json& members = asyncResp->res.jsonValue["Members"]; |
| members = nlohmann::json::array(); |
| for (const auto& feature : features) { |
| nlohmann::json::object_t member; |
| member["@odata.id"] = |
| absl::StrCat(parentUri, "/", std::get<0>(feature)); |
| members.push_back(member); |
| } |
| |
| asyncResp->res.jsonValue["@odata.id"] = parentUri; |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#GoogleNvmeFeatureCollection.GoogleNvmeFeatureCollection"; |
| asyncResp->res.jsonValue["Name"] = "NVMe Features Collection"; |
| asyncResp->res.jsonValue["Members@odata.count"] = members.size(); |
| }); |
| } |
| |
| inline void processNvmeFeatureGet( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& parentUri, const std::string& featureName, |
| const std::string& service, const std::string& path) { |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| managedStore::GetManagedObjectStore()->getAllProperties( |
| service, path, "xyz.openbmc_project.NVMe.FeatureStore", context, |
| [asyncResp, parentUri, featureName, service, path]( |
| const boost::system::error_code& ec, |
| const std::vector<std::pair< |
| std::string, dbus::utility::DbusVariantType>>& properties) { |
| if (ec) { |
| BMCWEB_LOG_ERROR << "Failed to get properties: " << ec; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string revision; |
| std::vector<std::tuple<std::string, std::string, std::string>> |
| featureCollection; |
| |
| bool revisionFound = false; |
| bool featureCollectionFound = false; |
| for (const auto& [propName, propVar] : properties) { |
| if (propName == "ProtoLibraryVersion") { |
| const std::string* revisionPtr = std::get_if<std::string>(&propVar); |
| if (revisionPtr != nullptr) { |
| revision = *revisionPtr; |
| revisionFound = true; |
| } |
| } else if (propName == "FeatureCollection") { |
| const auto* fcPtr = std::get_if< |
| std::vector<std::tuple<std::string, std::string, std::string>>>( |
| &propVar); |
| if (fcPtr != nullptr) { |
| featureCollection = *fcPtr; |
| featureCollectionFound = true; |
| } |
| } |
| } |
| |
| if (!revisionFound || !featureCollectionFound) { |
| BMCWEB_LOG_ERROR << "Failed to read ProtoLibraryVersion or " |
| "FeatureCollection"; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string featureIdStr; |
| std::string className; |
| bool featureFoundInCollection = false; |
| for (const auto& feature : featureCollection) { |
| if (std::get<0>(feature) == featureName) { |
| featureIdStr = std::get<1>(feature); |
| className = std::get<2>(feature); |
| featureFoundInCollection = true; |
| break; |
| } |
| } |
| |
| if (!featureFoundInCollection) { |
| messages::resourceNotFound(asyncResp->res, "GoogleNvmeFeature", |
| featureName); |
| return; |
| } |
| |
| asyncResp->res.jsonValue["@odata.id"] = |
| absl::StrCat(parentUri, "/", featureName); |
| asyncResp->res.jsonValue["@odata.type"] = |
| "#GoogleNvmeFeature.v1_0_0.GoogleNvmeFeature"; |
| asyncResp->res.jsonValue["Id"] = featureName; |
| asyncResp->res.jsonValue["Name"] = featureName; |
| asyncResp->res.jsonValue["FeatureId"] = featureIdStr; |
| |
| size_t pos = featureName.rfind('_'); |
| if (pos != std::string::npos) { |
| asyncResp->res.jsonValue["Select"] = featureName.substr(pos + 1); |
| } |
| |
| asyncResp->res.jsonValue["DataProto"]["ClassName"] = className; |
| asyncResp->res.jsonValue["DataProto"]["Revision"] = revision; |
| |
| managedStore::GetManagedObjectStore() |
| ->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| absl::AnyInvocable<void(const boost::system::error_code&, |
| const sdbusplus::message_t&, |
| const std::vector<uint8_t>&)>( |
| [asyncResp](const boost::system::error_code& ec2, |
| const sdbusplus::message_t& msg, |
| const std::vector<uint8_t>& payload) { |
| if (ec2) { |
| BMCWEB_LOG_ERROR << "Failed to call GetFeature: " |
| << ec2; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| const ::sd_bus_error* sd_err = nullptr; |
| if (msg) { |
| sd_err = msg.get_error(); |
| } |
| if (sd_err != nullptr) { |
| storageAddDbusError(asyncResp->res, "GetFeature", "", |
| sd_err->name, sd_err->message); |
| return; |
| } |
| asyncResp->res.jsonValue["DataProto"]["PayloadBase64"] = |
| crow::utility::base64encode(std::string_view( |
| reinterpret_cast<const char*>(payload.data()), |
| payload.size())); |
| }), |
| service, path, "xyz.openbmc_project.NVMe.FeatureStore", |
| "GetFeature", featureName); |
| }); |
| } |
| |
| inline absl::StatusOr<std::string> getPayloadBase64( |
| const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { |
| nlohmann::json dataProto; |
| if (!json_util::readJsonPatch(req, asyncResp->res, "DataProto", dataProto)) { |
| return absl::InvalidArgumentError("Invalid or Missing DataProto"); |
| } |
| |
| std::string payloadBase64; |
| if (!json_util::readJson(dataProto, asyncResp->res, "PayloadBase64", |
| payloadBase64)) { |
| return absl::InvalidArgumentError("Invalid or Missing PayloadBase64"); |
| } |
| |
| return payloadBase64; |
| } |
| |
| inline void processNvmeFeaturePatch( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& featureName, const std::string& payloadBase64, |
| const std::string& service, const std::string& path) { |
| std::string decodedPayload; |
| if (!crow::utility::base64Decode(payloadBase64, decodedPayload)) { |
| messages::propertyValueFormatError(asyncResp->res, payloadBase64, |
| "DataProto/PayloadBase64"); |
| return; |
| } |
| std::vector<uint8_t> payload(decodedPayload.begin(), decodedPayload.end()); |
| |
| BMCWEB_LOG_DEBUG << "Patching NVMeFeature " << featureName << " on " << path; |
| |
| managedStore::GetManagedObjectStore()->PostDbusCallToIoContextThreadSafe( |
| asyncResp->strand_, |
| [asyncResp, featureName](const boost::system::error_code& ec, |
| const sdbusplus::message_t& msg) { |
| const ::sd_bus_error* sd_err = msg.get_error(); |
| if (sd_err != nullptr) { |
| storageAddDbusError(asyncResp->res, "SetFeature", featureName, |
| sd_err->name, sd_err->message); |
| return; |
| } |
| if (ec) { |
| BMCWEB_LOG_ERROR << "Failed to call SetFeature: " << ec; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| messages::success(asyncResp->res); |
| }, |
| service, path, "xyz.openbmc_project.NVMe.FeatureStore", "SetFeature", |
| featureName, payload); |
| } |
| |
| inline void getFeatureStoreServiceForPath( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& path, |
| std::function<void(const std::string& service)> cb) { |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.NVMe.FeatureStore"}; |
| managedStore::ManagedObjectStoreContext context(asyncResp); |
| storage_utils::getDbusObject( |
| path, interfaces, context, |
| [asyncResp, path, cb = std::move(cb)]( |
| const boost::system::error_code& ec, |
| const dbus::utility::MapperGetObject& objects) mutable { |
| if (ec || objects.empty()) { |
| BMCWEB_LOG_ERROR << "Failed to find FeatureStore interface for " |
| << path; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| std::move(cb)(objects.front().first); |
| }); |
| } |
| |
| inline void handleControllerNvmeFeaturesCollectionGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& storageId, |
| const std::string& controllerId) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| BMCWEB_LOG_DEBUG << "Get NVMeFeatures Collection for controller " |
| << controllerId; |
| |
| storage_utils::findStorageAndController( |
| asyncResp, storageId, controllerId, |
| [asyncResp, systemName, storageId, controllerId]( |
| const sdbusplus::message::object_path& path, |
| const dbus::utility::MapperServiceMap& ifaces) { |
| std::optional<std::string> service = storage_utils::matchServiceName( |
| ifaces, "xyz.openbmc_project.NVMe.FeatureStore"); |
| if (!service) { |
| BMCWEB_LOG_ERROR << "Failed to find FeatureStore interface for " |
| << path.str; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string parentUri(crow::utility::urlFromPieces( |
| "redfish", "v1", "Systems", systemName, |
| "Storage", storageId, "Controllers", |
| controllerId, "Oem", "Google", "Features") |
| .buffer()); |
| processNvmeFeaturesCollectionGet(asyncResp, parentUri, *service, |
| path.str); |
| }); |
| } |
| |
| inline bool parseNvmeFeatureProperties( |
| const std::vector<std::pair<std::string, dbus::utility::DbusVariantType>>& |
| properties, |
| const std::string& featureName, std::string& revision, |
| std::string& featureIdStr, std::string& className, crow::Response& res) { |
| std::vector<std::tuple<std::string, std::string, std::string>> |
| featureCollection; |
| |
| bool revisionFound = false; |
| bool featureCollectionFound = false; |
| for (const auto& [propName, propVar] : properties) { |
| if (propName == "ProtoLibraryVersion") { |
| const std::string* revisionPtr = std::get_if<std::string>(&propVar); |
| if (revisionPtr != nullptr) { |
| revision = *revisionPtr; |
| revisionFound = true; |
| } |
| } else if (propName == "FeatureCollection") { |
| const auto* fcPtr = std::get_if< |
| std::vector<std::tuple<std::string, std::string, std::string>>>( |
| &propVar); |
| if (fcPtr != nullptr) { |
| featureCollection = *fcPtr; |
| featureCollectionFound = true; |
| } |
| } |
| } |
| |
| if (!revisionFound || !featureCollectionFound) { |
| BMCWEB_LOG_ERROR << "Failed to read ProtoLibraryVersion or " |
| "FeatureCollection"; |
| messages::internalError(res); |
| return false; |
| } |
| |
| bool featureFoundInCollection = false; |
| for (const auto& feature : featureCollection) { |
| if (std::get<0>(feature) == featureName) { |
| featureIdStr = std::get<1>(feature); |
| className = std::get<2>(feature); |
| featureFoundInCollection = true; |
| break; |
| } |
| } |
| |
| if (!featureFoundInCollection) { |
| messages::resourceNotFound(res, "GoogleNvmeFeature", featureName); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| inline void handleControllerNvmeFeatureGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& storageId, |
| const std::string& controllerId, const std::string& featureName) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| BMCWEB_LOG_DEBUG << "Get NVMeFeature " << featureName; |
| |
| storage_utils::findStorageAndController( |
| asyncResp, storageId, controllerId, |
| [asyncResp, systemName, storageId, controllerId, featureName]( |
| const sdbusplus::message::object_path& path, |
| const dbus::utility::MapperServiceMap& ifaces) { |
| std::optional<std::string> service = storage_utils::matchServiceName( |
| ifaces, "xyz.openbmc_project.NVMe.FeatureStore"); |
| if (!service) { |
| BMCWEB_LOG_ERROR << "Failed to find FeatureStore interface for " |
| << path.str; |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| std::string parentUri(crow::utility::urlFromPieces( |
| "redfish", "v1", "Systems", systemName, |
| "Storage", storageId, "Controllers", |
| controllerId, "Oem", "Google", "Features") |
| .buffer()); |
| processNvmeFeatureGet(asyncResp, parentUri, featureName, *service, |
| path.str); |
| }); |
| } |
| |
| inline void handleControllerNvmeFeaturePatch( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& /*systemName*/, const std::string& storageId, |
| const std::string& controllerId, const std::string& featureName) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| absl::StatusOr<std::string> payloadBase64 = getPayloadBase64(req, asyncResp); |
| if (!payloadBase64.ok()) { |
| BMCWEB_LOG_ERROR << "Failed to parse Request Payload for " << featureName |
| << " Base64: " << payloadBase64.status(); |
| return; |
| } |
| |
| storage_utils::findStorageAndController( |
| asyncResp, storageId, controllerId, |
| [asyncResp, featureName, payloadBase64 = std::move(*payloadBase64)]( |
| const sdbusplus::message::object_path& path, |
| const dbus::utility::MapperServiceMap& ifaces) { |
| auto service = storage_utils::matchServiceName( |
| ifaces, "xyz.openbmc_project.NVMe.FeatureStore"); |
| if (!service) { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| |
| processNvmeFeaturePatch(asyncResp, featureName, payloadBase64, *service, |
| path.str); |
| }); |
| } |
| |
| inline void handleStorageNvmeFeaturesCollectionGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& storageId) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| BMCWEB_LOG_DEBUG << "Get NVMeFeatures Collection for storage " << storageId; |
| |
| storage_utils::findStorage( |
| asyncResp, storageId, |
| [asyncResp, systemName, |
| storageId](const sdbusplus::message::object_path& storagePath) { |
| getFeatureStoreServiceForPath( |
| asyncResp, storagePath.str, |
| [asyncResp, systemName, storageId, |
| storagePath](const std::string& service) { |
| std::string parentUri( |
| crow::utility::urlFromPieces("redfish", "v1", "Systems", |
| systemName, "Storage", storageId, |
| "Oem", "Google", "Features") |
| .buffer()); |
| processNvmeFeaturesCollectionGet(asyncResp, parentUri, service, |
| storagePath.str); |
| }); |
| }); |
| } |
| |
| inline void handleStorageNvmeFeatureGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& storageId, |
| const std::string& featureName) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| BMCWEB_LOG_DEBUG << "Get NVMeFeature " << featureName; |
| |
| storage_utils::findStorage( |
| asyncResp, storageId, |
| [asyncResp, systemName, storageId, |
| featureName](const sdbusplus::message::object_path& storagePath) { |
| getFeatureStoreServiceForPath( |
| asyncResp, storagePath.str, |
| [asyncResp, systemName, storageId, featureName, |
| storagePath](const std::string& service) { |
| std::string parentUri( |
| crow::utility::urlFromPieces("redfish", "v1", "Systems", |
| systemName, "Storage", storageId, |
| "Oem", "Google", "Features") |
| .buffer()); |
| processNvmeFeatureGet(asyncResp, parentUri, featureName, service, |
| storagePath.str); |
| }); |
| }); |
| } |
| |
| inline void handleStorageNvmeFeaturePatch( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& /*systemName*/, const std::string& storageId, |
| const std::string& featureName) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| absl::StatusOr<std::string> payloadBase64 = getPayloadBase64(req, asyncResp); |
| if (!payloadBase64.ok()) { |
| BMCWEB_LOG_ERROR << "Failed to parse Request Payload for " << featureName |
| << " Base64: " << payloadBase64.status(); |
| return; |
| } |
| |
| storage_utils::findStorage( |
| asyncResp, storageId, |
| [asyncResp, featureName, payloadBase64 = std::move(*payloadBase64)]( |
| const sdbusplus::message::object_path& storagePath) { |
| getFeatureStoreServiceForPath( |
| asyncResp, storagePath.str, |
| [asyncResp, featureName, payloadBase64, |
| storagePath](const std::string& service) { |
| processNvmeFeaturePatch(asyncResp, featureName, payloadBase64, |
| service, storagePath.str); |
| }); |
| }); |
| } |
| |
| inline void findVolumePath( |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& storageId, const std::string& volumeId, |
| std::function<void(const sdbusplus::message::object_path& path)> cb) { |
| storage_utils::findStorage( |
| asyncResp, storageId, |
| [asyncResp, volumeId, cb = std::move(cb)]( |
| const sdbusplus::message::object_path& storagePath) mutable { |
| constexpr std::array<std::string_view, 1> interfaces = { |
| "xyz.openbmc_project.Inventory.Item.Volume"}; |
| managedStore::ManagedObjectStoreContext requestContext(asyncResp); |
| managedStore::GetManagedObjectStore()->getAssociatedSubTree( |
| storagePath / "containing", |
| sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), |
| 0, interfaces, requestContext, |
| [asyncResp, volumeId, cb = std::move(cb)]( |
| const boost::system::error_code& ec, |
| const dbus::utility::MapperGetSubTreeResponse& |
| subtree) mutable { |
| if (ec) { |
| messages::internalError(asyncResp->res); |
| return; |
| } |
| for (const auto& [path, ifaces] : subtree) { |
| if (sdbusplus::message::object_path(path).filename() == |
| volumeId) { |
| std::move(cb)(path); |
| return; |
| } |
| } |
| messages::resourceNotFound(asyncResp->res, "Volume", volumeId); |
| }); |
| }); |
| } |
| |
| inline void handleVolumeNvmeFeaturesCollectionGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& storageId, |
| const std::string& volumeId) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| BMCWEB_LOG_DEBUG << "Get NVMeFeatures Collection for volume " << volumeId; |
| |
| findVolumePath( |
| asyncResp, storageId, volumeId, |
| [asyncResp, systemName, storageId, |
| volumeId](const sdbusplus::message::object_path& volumePath) { |
| getFeatureStoreServiceForPath( |
| asyncResp, volumePath.str, |
| [asyncResp, systemName, storageId, volumeId, |
| volumePath](const std::string& service) { |
| std::string parentUri(crow::utility::urlFromPieces( |
| "redfish", "v1", "Systems", systemName, |
| "Storage", storageId, "Volumes", |
| volumeId, "Oem", "Google", "Features") |
| .buffer()); |
| processNvmeFeaturesCollectionGet(asyncResp, parentUri, service, |
| volumePath.str); |
| }); |
| }); |
| } |
| |
| inline void handleVolumeNvmeFeatureGet( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& systemName, const std::string& storageId, |
| const std::string& volumeId, const std::string& featureName) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| BMCWEB_LOG_DEBUG << "Get NVMeFeature " << featureName; |
| |
| findVolumePath( |
| asyncResp, storageId, volumeId, |
| [asyncResp, systemName, storageId, volumeId, |
| featureName](const sdbusplus::message::object_path& volumePath) { |
| getFeatureStoreServiceForPath( |
| asyncResp, volumePath.str, |
| [asyncResp, systemName, storageId, volumeId, featureName, |
| volumePath](const std::string& service) { |
| std::string parentUri(crow::utility::urlFromPieces( |
| "redfish", "v1", "Systems", systemName, |
| "Storage", storageId, "Volumes", |
| volumeId, "Oem", "Google", "Features") |
| .buffer()); |
| processNvmeFeatureGet(asyncResp, parentUri, featureName, service, |
| volumePath.str); |
| }); |
| }); |
| } |
| |
| inline void handleVolumeNvmeFeaturePatch( |
| App& app, const crow::Request& req, |
| const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| const std::string& /*systemName*/, const std::string& storageId, |
| const std::string& volumeId, const std::string& featureName) { |
| if (!redfish::setUpRedfishRoute(app, req, asyncResp)) { |
| return; |
| } |
| |
| absl::StatusOr<std::string> payloadBase64 = getPayloadBase64(req, asyncResp); |
| if (!payloadBase64.ok()) { |
| BMCWEB_LOG_ERROR << "Failed to parse Request Payload for " << featureName |
| << " Base64: " << payloadBase64.status(); |
| return; |
| } |
| |
| findVolumePath( |
| asyncResp, storageId, volumeId, |
| [asyncResp, featureName, payloadBase64 = std::move(*payloadBase64)]( |
| const sdbusplus::message::object_path& volumePath) { |
| getFeatureStoreServiceForPath( |
| asyncResp, volumePath.str, |
| [asyncResp, featureName, payloadBase64, |
| volumePath](const std::string& service) { |
| processNvmeFeaturePatch(asyncResp, featureName, payloadBase64, |
| service, volumePath.str); |
| }); |
| }); |
| } |
| |
| inline void requestRoutesNvmeFeatures(App& app) { |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/Systems/<str>/Storage/<str>/Controllers/<str>/Oem/" |
| "Google/Features/") |
| .privileges(redfish::privileges::getStorageController) |
| .methods(boost::beast::http::verb::get)(std::bind_front( |
| handleControllerNvmeFeaturesCollectionGet, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/Systems/<str>/Storage/<str>/Controllers/<str>/Oem/" |
| "Google/Features/<str>/") |
| .privileges(redfish::privileges::getStorageController) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleControllerNvmeFeatureGet, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/Systems/<str>/Storage/<str>/Controllers/<str>/Oem/" |
| "Google/Features/<str>/") |
| .privileges(redfish::privileges::patchStorageController) |
| .methods(boost::beast::http::verb::patch)( |
| std::bind_front(handleControllerNvmeFeaturePatch, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/Systems/<str>/Storage/<str>/Oem/Google/Features/") |
| .privileges(redfish::privileges::getStorage) |
| .methods(boost::beast::http::verb::get)(std::bind_front( |
| handleStorageNvmeFeaturesCollectionGet, std::ref(app))); |
| |
| BMCWEB_ROUTE( |
| app, "/redfish/v1/Systems/<str>/Storage/<str>/Oem/Google/Features/<str>/") |
| .privileges(redfish::privileges::getStorage) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleStorageNvmeFeatureGet, std::ref(app))); |
| |
| BMCWEB_ROUTE( |
| app, "/redfish/v1/Systems/<str>/Storage/<str>/Oem/Google/Features/<str>/") |
| .privileges(redfish::privileges::patchStorage) |
| .methods(boost::beast::http::verb::patch)( |
| std::bind_front(handleStorageNvmeFeaturePatch, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/Systems/<str>/Storage/<str>/Volumes/<str>/Oem/" |
| "Google/Features/") |
| .privileges(redfish::privileges::getVolume) |
| .methods(boost::beast::http::verb::get)(std::bind_front( |
| handleVolumeNvmeFeaturesCollectionGet, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/Systems/<str>/Storage/<str>/Volumes/<str>/Oem/" |
| "Google/Features/<str>/") |
| .privileges(redfish::privileges::getVolume) |
| .methods(boost::beast::http::verb::get)( |
| std::bind_front(handleVolumeNvmeFeatureGet, std::ref(app))); |
| |
| BMCWEB_ROUTE(app, |
| "/redfish/v1/Systems/<str>/Storage/<str>/Volumes/<str>/Oem/" |
| "Google/Features/<str>/") |
| .privileges(redfish::privileges::patchVolume) |
| .methods(boost::beast::http::verb::patch)( |
| std::bind_front(handleVolumeNvmeFeaturePatch, std::ref(app))); |
| } |
| } // namespace redfish |
| |
| #endif // THIRD_PARTY_GBMCWEB_REDFISH_CORE_LIB_NVME_FEATURES_H_ |
