1 /* 2 // Copyright (c) 2018 Intel Corporation 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 */ 16 #pragma once 17 18 #include "app.hpp" 19 #include "dbus_utility.hpp" 20 #include "health.hpp" 21 #include "led.hpp" 22 #include "query.hpp" 23 #include "registries/privilege_registry.hpp" 24 #include "utils/collection.hpp" 25 #include "utils/dbus_utils.hpp" 26 #include "utils/json_utils.hpp" 27 28 #include <boost/system/error_code.hpp> 29 #include <sdbusplus/asio/property.hpp> 30 #include <sdbusplus/unpack_properties.hpp> 31 32 #include <array> 33 #include <string_view> 34 35 namespace redfish 36 { 37 38 /** 39 * @brief Retrieves chassis state properties over dbus 40 * 41 * @param[in] aResp - Shared pointer for completing asynchronous calls. 42 * 43 * @return None. 44 */ 45 inline void getChassisState(std::shared_ptr<bmcweb::AsyncResp> aResp) 46 { 47 // crow::connections::systemBus->async_method_call( 48 sdbusplus::asio::getProperty<std::string>( 49 *crow::connections::systemBus, "xyz.openbmc_project.State.Chassis", 50 "/xyz/openbmc_project/state/chassis0", 51 "xyz.openbmc_project.State.Chassis", "CurrentPowerState", 52 [aResp{std::move(aResp)}](const boost::system::error_code ec, 53 const std::string& chassisState) { 54 if (ec) 55 { 56 if (ec == boost::system::errc::host_unreachable) 57 { 58 // Service not available, no error, just don't return 59 // chassis state info 60 BMCWEB_LOG_DEBUG << "Service not available " << ec; 61 return; 62 } 63 BMCWEB_LOG_DEBUG << "DBUS response error " << ec; 64 messages::internalError(aResp->res); 65 return; 66 } 67 68 BMCWEB_LOG_DEBUG << "Chassis state: " << chassisState; 69 // Verify Chassis State 70 if (chassisState == "xyz.openbmc_project.State.Chassis.PowerState.On") 71 { 72 aResp->res.jsonValue["PowerState"] = "On"; 73 aResp->res.jsonValue["Status"]["State"] = "Enabled"; 74 } 75 else if (chassisState == 76 "xyz.openbmc_project.State.Chassis.PowerState.Off") 77 { 78 aResp->res.jsonValue["PowerState"] = "Off"; 79 aResp->res.jsonValue["Status"]["State"] = "StandbyOffline"; 80 } 81 }); 82 } 83 84 inline void getIntrusionByService(std::shared_ptr<bmcweb::AsyncResp> aResp, 85 const std::string& service, 86 const std::string& objPath) 87 { 88 BMCWEB_LOG_DEBUG << "Get intrusion status by service \n"; 89 90 sdbusplus::asio::getProperty<std::string>( 91 *crow::connections::systemBus, service, objPath, 92 "xyz.openbmc_project.Chassis.Intrusion", "Status", 93 [aResp{std::move(aResp)}](const boost::system::error_code ec, 94 const std::string& value) { 95 if (ec) 96 { 97 // do not add err msg in redfish response, because this is not 98 // mandatory property 99 BMCWEB_LOG_ERROR << "DBUS response error " << ec << "\n"; 100 return; 101 } 102 103 aResp->res.jsonValue["PhysicalSecurity"]["IntrusionSensorNumber"] = 1; 104 aResp->res.jsonValue["PhysicalSecurity"]["IntrusionSensor"] = value; 105 }); 106 } 107 108 /** 109 * Retrieves physical security properties over dbus 110 */ 111 inline void getPhysicalSecurityData(std::shared_ptr<bmcweb::AsyncResp> aResp) 112 { 113 constexpr std::array<std::string_view, 1> interfaces = { 114 "xyz.openbmc_project.Chassis.Intrusion"}; 115 dbus::utility::getSubTree( 116 "/xyz/openbmc_project/Intrusion", 1, interfaces, 117 [aResp{std::move(aResp)}]( 118 const boost::system::error_code& ec, 119 const dbus::utility::MapperGetSubTreeResponse& subtree) { 120 if (ec) 121 { 122 // do not add err msg in redfish response, because this is not 123 // mandatory property 124 BMCWEB_LOG_INFO << "DBUS error: no matched iface " << ec << "\n"; 125 return; 126 } 127 // Iterate over all retrieved ObjectPaths. 128 for (const auto& object : subtree) 129 { 130 for (const auto& service : object.second) 131 { 132 getIntrusionByService(aResp, service.first, object.first); 133 return; 134 } 135 } 136 }); 137 } 138 139 inline void handleChassisCollectionGet( 140 App& app, const crow::Request& req, 141 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) 142 { 143 if (!redfish::setUpRedfishRoute(app, req, asyncResp)) 144 { 145 return; 146 } 147 asyncResp->res.jsonValue["@odata.type"] = 148 "#ChassisCollection.ChassisCollection"; 149 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Chassis"; 150 asyncResp->res.jsonValue["Name"] = "Chassis Collection"; 151 152 constexpr std::array<std::string_view, 2> interfaces{ 153 "xyz.openbmc_project.Inventory.Item.Board", 154 "xyz.openbmc_project.Inventory.Item.Chassis"}; 155 collection_util::getCollectionMembers( 156 asyncResp, boost::urls::url("/redfish/v1/Chassis"), interfaces); 157 } 158 159 /** 160 * ChassisCollection derived class for delivering Chassis Collection Schema 161 * Functions triggers appropriate requests on DBus 162 */ 163 inline void requestRoutesChassisCollection(App& app) 164 { 165 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/") 166 .privileges(redfish::privileges::getChassisCollection) 167 .methods(boost::beast::http::verb::get)( 168 std::bind_front(handleChassisCollectionGet, std::ref(app))); 169 } 170 171 inline void 172 getChassisLocationCode(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 173 const std::string& connectionName, 174 const std::string& path) 175 { 176 sdbusplus::asio::getProperty<std::string>( 177 *crow::connections::systemBus, connectionName, path, 178 "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode", 179 [asyncResp](const boost::system::error_code ec, 180 const std::string& property) { 181 if (ec) 182 { 183 BMCWEB_LOG_DEBUG << "DBUS response error for Location"; 184 messages::internalError(asyncResp->res); 185 return; 186 } 187 188 asyncResp->res.jsonValue["Location"]["PartLocation"]["ServiceLabel"] = 189 property; 190 }); 191 } 192 193 inline void getChassisUUID(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 194 const std::string& connectionName, 195 const std::string& path) 196 { 197 sdbusplus::asio::getProperty<std::string>( 198 *crow::connections::systemBus, connectionName, path, 199 "xyz.openbmc_project.Common.UUID", "UUID", 200 [asyncResp](const boost::system::error_code ec, 201 const std::string& chassisUUID) { 202 if (ec) 203 { 204 BMCWEB_LOG_DEBUG << "DBUS response error for UUID"; 205 messages::internalError(asyncResp->res); 206 return; 207 } 208 asyncResp->res.jsonValue["UUID"] = chassisUUID; 209 }); 210 } 211 212 inline void 213 handleChassisGet(App& app, const crow::Request& req, 214 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 215 const std::string& chassisId) 216 { 217 if (!redfish::setUpRedfishRoute(app, req, asyncResp)) 218 { 219 return; 220 } 221 constexpr std::array<std::string_view, 2> interfaces = { 222 "xyz.openbmc_project.Inventory.Item.Board", 223 "xyz.openbmc_project.Inventory.Item.Chassis"}; 224 225 dbus::utility::getSubTree( 226 "/xyz/openbmc_project/inventory", 0, interfaces, 227 [asyncResp, chassisId(std::string(chassisId))]( 228 const boost::system::error_code& ec, 229 const dbus::utility::MapperGetSubTreeResponse& subtree) { 230 if (ec) 231 { 232 messages::internalError(asyncResp->res); 233 return; 234 } 235 // Iterate over all retrieved ObjectPaths. 236 for (const std::pair< 237 std::string, 238 std::vector<std::pair<std::string, std::vector<std::string>>>>& 239 object : subtree) 240 { 241 const std::string& path = object.first; 242 const std::vector<std::pair<std::string, std::vector<std::string>>>& 243 connectionNames = object.second; 244 245 sdbusplus::message::object_path objPath(path); 246 if (objPath.filename() != chassisId) 247 { 248 continue; 249 } 250 251 auto health = std::make_shared<HealthPopulate>(asyncResp); 252 253 sdbusplus::asio::getProperty<std::vector<std::string>>( 254 *crow::connections::systemBus, 255 "xyz.openbmc_project.ObjectMapper", path + "/all_sensors", 256 "xyz.openbmc_project.Association", "endpoints", 257 [health](const boost::system::error_code ec2, 258 const std::vector<std::string>& resp) { 259 if (ec2) 260 { 261 return; // no sensors = no failures 262 } 263 health->inventory = resp; 264 }); 265 266 health->populate(); 267 268 if (connectionNames.empty()) 269 { 270 BMCWEB_LOG_ERROR << "Got 0 Connection names"; 271 continue; 272 } 273 274 asyncResp->res.jsonValue["@odata.type"] = 275 "#Chassis.v1_16_0.Chassis"; 276 asyncResp->res.jsonValue["@odata.id"] = 277 "/redfish/v1/Chassis/" + chassisId; 278 asyncResp->res.jsonValue["Name"] = "Chassis Collection"; 279 asyncResp->res.jsonValue["ChassisType"] = "RackMount"; 280 asyncResp->res.jsonValue["Actions"]["#Chassis.Reset"]["target"] = 281 "/redfish/v1/Chassis/" + chassisId + "/Actions/Chassis.Reset"; 282 asyncResp->res 283 .jsonValue["Actions"]["#Chassis.Reset"]["@Redfish.ActionInfo"] = 284 "/redfish/v1/Chassis/" + chassisId + "/ResetActionInfo"; 285 asyncResp->res.jsonValue["PCIeDevices"]["@odata.id"] = 286 "/redfish/v1/Systems/system/PCIeDevices"; 287 288 sdbusplus::asio::getProperty<std::vector<std::string>>( 289 *crow::connections::systemBus, 290 "xyz.openbmc_project.ObjectMapper", path + "/drive", 291 "xyz.openbmc_project.Association", "endpoints", 292 [asyncResp, chassisId](const boost::system::error_code ec3, 293 const std::vector<std::string>& resp) { 294 if (ec3 || resp.empty()) 295 { 296 return; // no drives = no failures 297 } 298 299 nlohmann::json reference; 300 reference["@odata.id"] = crow::utility::urlFromPieces( 301 "redfish", "v1", "Chassis", chassisId, "Drives"); 302 asyncResp->res.jsonValue["Drives"] = std::move(reference); 303 }); 304 305 const std::string& connectionName = connectionNames[0].first; 306 307 const std::vector<std::string>& interfaces2 = 308 connectionNames[0].second; 309 const std::array<const char*, 2> hasIndicatorLed = { 310 "xyz.openbmc_project.Inventory.Item.Panel", 311 "xyz.openbmc_project.Inventory.Item.Board.Motherboard"}; 312 313 const std::string assetTagInterface = 314 "xyz.openbmc_project.Inventory.Decorator.AssetTag"; 315 if (std::find(interfaces2.begin(), interfaces2.end(), 316 assetTagInterface) != interfaces2.end()) 317 { 318 sdbusplus::asio::getProperty<std::string>( 319 *crow::connections::systemBus, connectionName, path, 320 assetTagInterface, "AssetTag", 321 [asyncResp, chassisId(std::string(chassisId))]( 322 const boost::system::error_code ec2, 323 const std::string& property) { 324 if (ec2) 325 { 326 BMCWEB_LOG_DEBUG << "DBus response error for AssetTag"; 327 messages::internalError(asyncResp->res); 328 return; 329 } 330 asyncResp->res.jsonValue["AssetTag"] = property; 331 }); 332 } 333 334 for (const char* interface : hasIndicatorLed) 335 { 336 if (std::find(interfaces2.begin(), interfaces2.end(), 337 interface) != interfaces2.end()) 338 { 339 getIndicatorLedState(asyncResp); 340 getLocationIndicatorActive(asyncResp); 341 break; 342 } 343 } 344 345 sdbusplus::asio::getAllProperties( 346 *crow::connections::systemBus, connectionName, path, 347 "xyz.openbmc_project.Inventory.Decorator.Asset", 348 [asyncResp, chassisId(std::string(chassisId))]( 349 const boost::system::error_code /*ec2*/, 350 const dbus::utility::DBusPropertiesMap& propertiesList) { 351 const std::string* partNumber = nullptr; 352 const std::string* serialNumber = nullptr; 353 const std::string* manufacturer = nullptr; 354 const std::string* model = nullptr; 355 const std::string* sparePartNumber = nullptr; 356 357 const bool success = sdbusplus::unpackPropertiesNoThrow( 358 dbus_utils::UnpackErrorPrinter(), propertiesList, 359 "PartNumber", partNumber, "SerialNumber", serialNumber, 360 "Manufacturer", manufacturer, "Model", model, 361 "SparePartNumber", sparePartNumber); 362 363 if (!success) 364 { 365 messages::internalError(asyncResp->res); 366 return; 367 } 368 369 if (partNumber != nullptr) 370 { 371 asyncResp->res.jsonValue["PartNumber"] = *partNumber; 372 } 373 374 if (serialNumber != nullptr) 375 { 376 asyncResp->res.jsonValue["SerialNumber"] = *serialNumber; 377 } 378 379 if (manufacturer != nullptr) 380 { 381 asyncResp->res.jsonValue["Manufacturer"] = *manufacturer; 382 } 383 384 if (model != nullptr) 385 { 386 asyncResp->res.jsonValue["Model"] = *model; 387 } 388 389 // SparePartNumber is optional on D-Bus 390 // so skip if it is empty 391 if (sparePartNumber != nullptr && !sparePartNumber->empty()) 392 { 393 asyncResp->res.jsonValue["SparePartNumber"] = 394 *sparePartNumber; 395 } 396 397 asyncResp->res.jsonValue["Name"] = chassisId; 398 asyncResp->res.jsonValue["Id"] = chassisId; 399 #ifdef BMCWEB_ALLOW_DEPRECATED_POWER_THERMAL 400 asyncResp->res.jsonValue["Thermal"]["@odata.id"] = 401 "/redfish/v1/Chassis/" + chassisId + "/Thermal"; 402 // Power object 403 asyncResp->res.jsonValue["Power"]["@odata.id"] = 404 "/redfish/v1/Chassis/" + chassisId + "/Power"; 405 #endif 406 #ifdef BMCWEB_NEW_POWERSUBSYSTEM_THERMALSUBSYSTEM 407 asyncResp->res.jsonValue["ThermalSubsystem"]["@odata.id"] = 408 crow::utility::urlFromPieces("redfish", "v1", "Chassis", 409 chassisId, "ThermalSubsystem"); 410 asyncResp->res.jsonValue["PowerSubsystem"]["@odata.id"] = 411 crow::utility::urlFromPieces("redfish", "v1", "Chassis", 412 chassisId, "PowerSubsystem"); 413 asyncResp->res.jsonValue["EnvironmentMetrics"]["@odata.id"] = 414 crow::utility::urlFromPieces("redfish", "v1", "Chassis", 415 chassisId, 416 "EnvironmentMetrics"); 417 #endif 418 // SensorCollection 419 asyncResp->res.jsonValue["Sensors"]["@odata.id"] = 420 "/redfish/v1/Chassis/" + chassisId + "/Sensors"; 421 asyncResp->res.jsonValue["Status"]["State"] = "Enabled"; 422 423 nlohmann::json::array_t computerSystems; 424 nlohmann::json::object_t system; 425 system["@odata.id"] = "/redfish/v1/Systems/system"; 426 computerSystems.push_back(std::move(system)); 427 asyncResp->res.jsonValue["Links"]["ComputerSystems"] = 428 std::move(computerSystems); 429 430 nlohmann::json::array_t managedBy; 431 nlohmann::json::object_t manager; 432 manager["@odata.id"] = "/redfish/v1/Managers/bmc"; 433 managedBy.push_back(std::move(manager)); 434 asyncResp->res.jsonValue["Links"]["ManagedBy"] = 435 std::move(managedBy); 436 getChassisState(asyncResp); 437 }); 438 439 for (const auto& interface : interfaces2) 440 { 441 if (interface == "xyz.openbmc_project.Common.UUID") 442 { 443 getChassisUUID(asyncResp, connectionName, path); 444 } 445 else if (interface == 446 "xyz.openbmc_project.Inventory.Decorator.LocationCode") 447 { 448 getChassisLocationCode(asyncResp, connectionName, path); 449 } 450 } 451 452 return; 453 } 454 455 // Couldn't find an object with that name. return an error 456 messages::resourceNotFound(asyncResp->res, "Chassis", chassisId); 457 }); 458 459 getPhysicalSecurityData(asyncResp); 460 } 461 462 inline void 463 handleChassisPatch(App& app, const crow::Request& req, 464 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 465 const std::string& param) 466 { 467 if (!redfish::setUpRedfishRoute(app, req, asyncResp)) 468 { 469 return; 470 } 471 std::optional<bool> locationIndicatorActive; 472 std::optional<std::string> indicatorLed; 473 474 if (param.empty()) 475 { 476 return; 477 } 478 479 if (!json_util::readJsonPatch( 480 req, asyncResp->res, "LocationIndicatorActive", 481 locationIndicatorActive, "IndicatorLED", indicatorLed)) 482 { 483 return; 484 } 485 486 // TODO (Gunnar): Remove IndicatorLED after enough time has passed 487 if (!locationIndicatorActive && !indicatorLed) 488 { 489 return; // delete this when we support more patch properties 490 } 491 if (indicatorLed) 492 { 493 asyncResp->res.addHeader( 494 boost::beast::http::field::warning, 495 "299 - \"IndicatorLED is deprecated. Use LocationIndicatorActive instead.\""); 496 } 497 498 constexpr std::array<std::string_view, 2> interfaces = { 499 "xyz.openbmc_project.Inventory.Item.Board", 500 "xyz.openbmc_project.Inventory.Item.Chassis"}; 501 502 const std::string& chassisId = param; 503 504 dbus::utility::getSubTree( 505 "/xyz/openbmc_project/inventory", 0, interfaces, 506 [asyncResp, chassisId, locationIndicatorActive, 507 indicatorLed](const boost::system::error_code ec, 508 const dbus::utility::MapperGetSubTreeResponse& subtree) { 509 if (ec) 510 { 511 messages::internalError(asyncResp->res); 512 return; 513 } 514 515 // Iterate over all retrieved ObjectPaths. 516 for (const std::pair< 517 std::string, 518 std::vector<std::pair<std::string, std::vector<std::string>>>>& 519 object : subtree) 520 { 521 const std::string& path = object.first; 522 const std::vector<std::pair<std::string, std::vector<std::string>>>& 523 connectionNames = object.second; 524 525 sdbusplus::message::object_path objPath(path); 526 if (objPath.filename() != chassisId) 527 { 528 continue; 529 } 530 531 if (connectionNames.empty()) 532 { 533 BMCWEB_LOG_ERROR << "Got 0 Connection names"; 534 continue; 535 } 536 537 const std::vector<std::string>& interfaces3 = 538 connectionNames[0].second; 539 540 const std::array<const char*, 2> hasIndicatorLed = { 541 "xyz.openbmc_project.Inventory.Item.Panel", 542 "xyz.openbmc_project.Inventory.Item.Board.Motherboard"}; 543 bool indicatorChassis = false; 544 for (const char* interface : hasIndicatorLed) 545 { 546 if (std::find(interfaces3.begin(), interfaces3.end(), 547 interface) != interfaces3.end()) 548 { 549 indicatorChassis = true; 550 break; 551 } 552 } 553 if (locationIndicatorActive) 554 { 555 if (indicatorChassis) 556 { 557 setLocationIndicatorActive(asyncResp, 558 *locationIndicatorActive); 559 } 560 else 561 { 562 messages::propertyUnknown(asyncResp->res, 563 "LocationIndicatorActive"); 564 } 565 } 566 if (indicatorLed) 567 { 568 if (indicatorChassis) 569 { 570 setIndicatorLedState(asyncResp, *indicatorLed); 571 } 572 else 573 { 574 messages::propertyUnknown(asyncResp->res, "IndicatorLED"); 575 } 576 } 577 return; 578 } 579 580 messages::resourceNotFound(asyncResp->res, "Chassis", chassisId); 581 }); 582 } 583 584 /** 585 * Chassis override class for delivering Chassis Schema 586 * Functions triggers appropriate requests on DBus 587 */ 588 inline void requestRoutesChassis(App& app) 589 { 590 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/") 591 .privileges(redfish::privileges::getChassis) 592 .methods(boost::beast::http::verb::get)( 593 std::bind_front(handleChassisGet, std::ref(app))); 594 595 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/") 596 .privileges(redfish::privileges::patchChassis) 597 .methods(boost::beast::http::verb::patch)( 598 std::bind_front(handleChassisPatch, std::ref(app))); 599 } 600 601 inline void 602 doChassisPowerCycle(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) 603 { 604 constexpr std::array<std::string_view, 1> interfaces = { 605 "xyz.openbmc_project.State.Chassis"}; 606 607 // Use mapper to get subtree paths. 608 dbus::utility::getSubTreePaths( 609 "/", 0, interfaces, 610 [asyncResp]( 611 const boost::system::error_code& ec, 612 const dbus::utility::MapperGetSubTreePathsResponse& chassisList) { 613 if (ec) 614 { 615 BMCWEB_LOG_DEBUG << "[mapper] Bad D-Bus request error: " << ec; 616 messages::internalError(asyncResp->res); 617 return; 618 } 619 620 const char* processName = "xyz.openbmc_project.State.Chassis"; 621 const char* interfaceName = "xyz.openbmc_project.State.Chassis"; 622 const char* destProperty = "RequestedPowerTransition"; 623 const std::string propertyValue = 624 "xyz.openbmc_project.State.Chassis.Transition.PowerCycle"; 625 std::string objectPath = "/xyz/openbmc_project/state/chassis_system0"; 626 627 /* Look for system reset chassis path */ 628 if ((std::find(chassisList.begin(), chassisList.end(), objectPath)) == 629 chassisList.end()) 630 { 631 /* We prefer to reset the full chassis_system, but if it doesn't 632 * exist on some platforms, fall back to a host-only power reset 633 */ 634 objectPath = "/xyz/openbmc_project/state/chassis0"; 635 } 636 637 crow::connections::systemBus->async_method_call( 638 [asyncResp](const boost::system::error_code ec2) { 639 // Use "Set" method to set the property value. 640 if (ec2) 641 { 642 BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec2; 643 messages::internalError(asyncResp->res); 644 return; 645 } 646 647 messages::success(asyncResp->res); 648 }, 649 processName, objectPath, "org.freedesktop.DBus.Properties", "Set", 650 interfaceName, destProperty, 651 dbus::utility::DbusVariantType{propertyValue}); 652 }); 653 } 654 655 inline void handleChassisResetActionInfoPost( 656 App& app, const crow::Request& req, 657 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 658 const std::string& /*chassisId*/) 659 { 660 if (!redfish::setUpRedfishRoute(app, req, asyncResp)) 661 { 662 return; 663 } 664 BMCWEB_LOG_DEBUG << "Post Chassis Reset."; 665 666 std::string resetType; 667 668 if (!json_util::readJsonAction(req, asyncResp->res, "ResetType", resetType)) 669 { 670 return; 671 } 672 673 if (resetType != "PowerCycle") 674 { 675 BMCWEB_LOG_DEBUG << "Invalid property value for ResetType: " 676 << resetType; 677 messages::actionParameterNotSupported(asyncResp->res, resetType, 678 "ResetType"); 679 680 return; 681 } 682 doChassisPowerCycle(asyncResp); 683 } 684 685 /** 686 * ChassisResetAction class supports the POST method for the Reset 687 * action. 688 * Function handles POST method request. 689 * Analyzes POST body before sending Reset request data to D-Bus. 690 */ 691 692 inline void requestRoutesChassisResetAction(App& app) 693 { 694 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Actions/Chassis.Reset/") 695 .privileges(redfish::privileges::postChassis) 696 .methods(boost::beast::http::verb::post)( 697 std::bind_front(handleChassisResetActionInfoPost, std::ref(app))); 698 } 699 700 inline void handleChassisResetActionInfoGet( 701 App& app, const crow::Request& req, 702 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, 703 const std::string& chassisId) 704 { 705 if (!redfish::setUpRedfishRoute(app, req, asyncResp)) 706 { 707 return; 708 } 709 asyncResp->res.jsonValue["@odata.type"] = "#ActionInfo.v1_1_2.ActionInfo"; 710 asyncResp->res.jsonValue["@odata.id"] = 711 "/redfish/v1/Chassis/" + chassisId + "/ResetActionInfo"; 712 asyncResp->res.jsonValue["Name"] = "Reset Action Info"; 713 714 asyncResp->res.jsonValue["Id"] = "ResetActionInfo"; 715 nlohmann::json::array_t parameters; 716 nlohmann::json::object_t parameter; 717 parameter["Name"] = "ResetType"; 718 parameter["Required"] = true; 719 parameter["DataType"] = "String"; 720 nlohmann::json::array_t allowed; 721 allowed.push_back("PowerCycle"); 722 parameter["AllowableValues"] = std::move(allowed); 723 parameters.push_back(std::move(parameter)); 724 725 asyncResp->res.jsonValue["Parameters"] = std::move(parameters); 726 } 727 728 /** 729 * ChassisResetActionInfo derived class for delivering Chassis 730 * ResetType AllowableValues using ResetInfo schema. 731 */ 732 inline void requestRoutesChassisResetActionInfo(App& app) 733 { 734 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ResetActionInfo/") 735 .privileges(redfish::privileges::getActionInfo) 736 .methods(boost::beast::http::verb::get)( 737 std::bind_front(handleChassisResetActionInfoGet, std::ref(app))); 738 } 739 740 } // namespace redfish 741