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 "health.hpp" 19 #include "led.hpp" 20 #include "node.hpp" 21 22 #include <boost/container/flat_map.hpp> 23 24 #include <variant> 25 26 namespace redfish 27 { 28 29 /** 30 * @brief Retrieves chassis state properties over dbus 31 * 32 * @param[in] aResp - Shared pointer for completing asynchronous calls. 33 * 34 * @return None. 35 */ 36 inline void getChassisState(std::shared_ptr<AsyncResp> aResp) 37 { 38 crow::connections::systemBus->async_method_call( 39 [aResp{std::move(aResp)}]( 40 const boost::system::error_code ec, 41 const std::variant<std::string>& chassisState) { 42 if (ec) 43 { 44 BMCWEB_LOG_DEBUG << "DBUS response error " << ec; 45 messages::internalError(aResp->res); 46 return; 47 } 48 49 const std::string* s = std::get_if<std::string>(&chassisState); 50 BMCWEB_LOG_DEBUG << "Chassis state: " << *s; 51 if (s != nullptr) 52 { 53 // Verify Chassis State 54 if (*s == "xyz.openbmc_project.State.Chassis.PowerState.On") 55 { 56 aResp->res.jsonValue["PowerState"] = "On"; 57 aResp->res.jsonValue["Status"]["State"] = "Enabled"; 58 } 59 else if (*s == 60 "xyz.openbmc_project.State.Chassis.PowerState.Off") 61 { 62 aResp->res.jsonValue["PowerState"] = "Off"; 63 aResp->res.jsonValue["Status"]["State"] = "StandbyOffline"; 64 } 65 } 66 }, 67 "xyz.openbmc_project.State.Chassis", 68 "/xyz/openbmc_project/state/chassis0", 69 "org.freedesktop.DBus.Properties", "Get", 70 "xyz.openbmc_project.State.Chassis", "CurrentPowerState"); 71 } 72 73 /** 74 * DBus types primitives for several generic DBus interfaces 75 * TODO(Pawel) consider move this to separate file into boost::dbus 76 */ 77 // Note, this is not a very useful Variant, but because it isn't used to get 78 // values, it should be as simple as possible 79 // TODO(ed) invent a nullvariant type 80 using VariantType = std::variant<bool, std::string, uint64_t, uint32_t>; 81 using ManagedObjectsType = std::vector<std::pair< 82 sdbusplus::message::object_path, 83 std::vector<std::pair<std::string, 84 std::vector<std::pair<std::string, VariantType>>>>>>; 85 86 using PropertiesType = boost::container::flat_map<std::string, VariantType>; 87 88 inline void getIntrusionByService(std::shared_ptr<AsyncResp> aResp, 89 const std::string& service, 90 const std::string& objPath) 91 { 92 BMCWEB_LOG_DEBUG << "Get intrusion status by service \n"; 93 94 crow::connections::systemBus->async_method_call( 95 [aResp{std::move(aResp)}](const boost::system::error_code ec, 96 const std::variant<std::string>& value) { 97 if (ec) 98 { 99 // do not add err msg in redfish response, because this is not 100 // mandatory property 101 BMCWEB_LOG_ERROR << "DBUS response error " << ec << "\n"; 102 return; 103 } 104 105 const std::string* status = std::get_if<std::string>(&value); 106 107 if (status == nullptr) 108 { 109 BMCWEB_LOG_ERROR << "intrusion status read error \n"; 110 return; 111 } 112 113 aResp->res.jsonValue["PhysicalSecurity"] = { 114 {"IntrusionSensorNumber", 1}, {"IntrusionSensor", *status}}; 115 }, 116 service, objPath, "org.freedesktop.DBus.Properties", "Get", 117 "xyz.openbmc_project.Chassis.Intrusion", "Status"); 118 } 119 120 /** 121 * Retrieves physical security properties over dbus 122 */ 123 inline void getPhysicalSecurityData(std::shared_ptr<AsyncResp> aResp) 124 { 125 crow::connections::systemBus->async_method_call( 126 [aResp{std::move(aResp)}]( 127 const boost::system::error_code ec, 128 const std::vector<std::pair< 129 std::string, 130 std::vector<std::pair<std::string, std::vector<std::string>>>>>& 131 subtree) { 132 if (ec) 133 { 134 // do not add err msg in redfish response, because this is not 135 // mandatory property 136 BMCWEB_LOG_ERROR << "DBUS error: no matched iface " << ec 137 << "\n"; 138 return; 139 } 140 // Iterate over all retrieved ObjectPaths. 141 for (const auto& object : subtree) 142 { 143 for (const auto& service : object.second) 144 { 145 getIntrusionByService(aResp, service.first, object.first); 146 return; 147 } 148 } 149 }, 150 "xyz.openbmc_project.ObjectMapper", 151 "/xyz/openbmc_project/object_mapper", 152 "xyz.openbmc_project.ObjectMapper", "GetSubTree", 153 "/xyz/openbmc_project/Intrusion", 1, 154 std::array<const char*, 1>{"xyz.openbmc_project.Chassis.Intrusion"}); 155 } 156 157 /** 158 * ChassisCollection derived class for delivering Chassis Collection Schema 159 */ 160 class ChassisCollection : public Node 161 { 162 public: 163 ChassisCollection(App& app) : Node(app, "/redfish/v1/Chassis/") 164 { 165 entityPrivileges = { 166 {boost::beast::http::verb::get, {{"Login"}}}, 167 {boost::beast::http::verb::head, {{"Login"}}}, 168 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 169 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 170 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 171 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 172 } 173 174 private: 175 /** 176 * Functions triggers appropriate requests on DBus 177 */ 178 void doGet(crow::Response& res, const crow::Request&, 179 const std::vector<std::string>&) override 180 { 181 res.jsonValue["@odata.type"] = "#ChassisCollection.ChassisCollection"; 182 res.jsonValue["@odata.id"] = "/redfish/v1/Chassis"; 183 res.jsonValue["Name"] = "Chassis Collection"; 184 185 const std::array<const char*, 2> interfaces = { 186 "xyz.openbmc_project.Inventory.Item.Board", 187 "xyz.openbmc_project.Inventory.Item.Chassis"}; 188 189 auto asyncResp = std::make_shared<AsyncResp>(res); 190 crow::connections::systemBus->async_method_call( 191 [asyncResp](const boost::system::error_code ec, 192 const std::vector<std::string>& chassisList) { 193 if (ec) 194 { 195 messages::internalError(asyncResp->res); 196 return; 197 } 198 nlohmann::json& chassisArray = 199 asyncResp->res.jsonValue["Members"]; 200 chassisArray = nlohmann::json::array(); 201 for (const std::string& objpath : chassisList) 202 { 203 std::size_t lastPos = objpath.rfind("/"); 204 if (lastPos == std::string::npos) 205 { 206 BMCWEB_LOG_ERROR << "Failed to find '/' in " << objpath; 207 continue; 208 } 209 chassisArray.push_back( 210 {{"@odata.id", "/redfish/v1/Chassis/" + 211 objpath.substr(lastPos + 1)}}); 212 } 213 214 asyncResp->res.jsonValue["Members@odata.count"] = 215 chassisArray.size(); 216 }, 217 "xyz.openbmc_project.ObjectMapper", 218 "/xyz/openbmc_project/object_mapper", 219 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", 220 "/xyz/openbmc_project/inventory", 0, interfaces); 221 } 222 }; 223 224 /** 225 * Chassis override class for delivering Chassis Schema 226 */ 227 class Chassis : public Node 228 { 229 public: 230 Chassis(App& app) : Node(app, "/redfish/v1/Chassis/<str>/", std::string()) 231 { 232 entityPrivileges = { 233 {boost::beast::http::verb::get, {{"Login"}}}, 234 {boost::beast::http::verb::head, {{"Login"}}}, 235 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 236 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 237 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 238 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 239 } 240 241 private: 242 /** 243 * Functions triggers appropriate requests on DBus 244 */ 245 void doGet(crow::Response& res, const crow::Request&, 246 const std::vector<std::string>& params) override 247 { 248 const std::array<const char*, 2> interfaces = { 249 "xyz.openbmc_project.Inventory.Item.Board", 250 "xyz.openbmc_project.Inventory.Item.Chassis"}; 251 252 // Check if there is required param, truly entering this shall be 253 // impossible. 254 if (params.size() != 1) 255 { 256 messages::internalError(res); 257 res.end(); 258 return; 259 } 260 const std::string& chassisId = params[0]; 261 262 auto asyncResp = std::make_shared<AsyncResp>(res); 263 crow::connections::systemBus->async_method_call( 264 [asyncResp, chassisId(std::string(chassisId))]( 265 const boost::system::error_code ec, 266 const crow::openbmc_mapper::GetSubTreeType& subtree) { 267 if (ec) 268 { 269 messages::internalError(asyncResp->res); 270 return; 271 } 272 // Iterate over all retrieved ObjectPaths. 273 for (const std::pair< 274 std::string, 275 std::vector< 276 std::pair<std::string, std::vector<std::string>>>>& 277 object : subtree) 278 { 279 const std::string& path = object.first; 280 const std::vector< 281 std::pair<std::string, std::vector<std::string>>>& 282 connectionNames = object.second; 283 284 if (!boost::ends_with(path, chassisId)) 285 { 286 continue; 287 } 288 289 auto health = std::make_shared<HealthPopulate>(asyncResp); 290 291 crow::connections::systemBus->async_method_call( 292 [health](const boost::system::error_code ec2, 293 std::variant<std::vector<std::string>>& resp) { 294 if (ec2) 295 { 296 return; // no sensors = no failures 297 } 298 std::vector<std::string>* data = 299 std::get_if<std::vector<std::string>>(&resp); 300 if (data == nullptr) 301 { 302 return; 303 } 304 health->inventory = std::move(*data); 305 }, 306 "xyz.openbmc_project.ObjectMapper", 307 path + "/all_sensors", 308 "org.freedesktop.DBus.Properties", "Get", 309 "xyz.openbmc_project.Association", "endpoints"); 310 311 health->populate(); 312 313 if (connectionNames.size() < 1) 314 { 315 BMCWEB_LOG_ERROR << "Got 0 Connection names"; 316 continue; 317 } 318 319 asyncResp->res.jsonValue["@odata.type"] = 320 "#Chassis.v1_10_0.Chassis"; 321 asyncResp->res.jsonValue["@odata.id"] = 322 "/redfish/v1/Chassis/" + chassisId; 323 asyncResp->res.jsonValue["Name"] = "Chassis Collection"; 324 asyncResp->res.jsonValue["ChassisType"] = "RackMount"; 325 asyncResp->res.jsonValue["Actions"]["#Chassis.Reset"] = { 326 {"target", "/redfish/v1/Chassis/" + chassisId + 327 "/Actions/Chassis.Reset"}, 328 {"@Redfish.ActionInfo", "/redfish/v1/Chassis/" + 329 chassisId + 330 "/ResetActionInfo"}}; 331 asyncResp->res.jsonValue["PCIeDevices"] = { 332 {"@odata.id", 333 "/redfish/v1/Systems/system/PCIeDevices"}}; 334 335 const std::string& connectionName = 336 connectionNames[0].first; 337 338 const std::vector<std::string>& interfaces2 = 339 connectionNames[0].second; 340 const std::array<const char*, 2> hasIndicatorLed = { 341 "xyz.openbmc_project.Inventory.Item.Panel", 342 "xyz.openbmc_project.Inventory.Item.Board.Motherboard"}; 343 344 for (const char* interface : hasIndicatorLed) 345 { 346 if (std::find(interfaces2.begin(), interfaces2.end(), 347 interface) != interfaces2.end()) 348 { 349 getIndicatorLedState(asyncResp); 350 break; 351 } 352 } 353 354 crow::connections::systemBus->async_method_call( 355 [asyncResp, chassisId(std::string(chassisId))]( 356 const boost::system::error_code /*ec2*/, 357 const std::vector<std::pair< 358 std::string, VariantType>>& propertiesList) { 359 for (const std::pair<std::string, VariantType>& 360 property : propertiesList) 361 { 362 // Store DBus properties that are also Redfish 363 // properties with same name and a string value 364 const std::string& propertyName = 365 property.first; 366 if ((propertyName == "PartNumber") || 367 (propertyName == "SerialNumber") || 368 (propertyName == "Manufacturer") || 369 (propertyName == "Model")) 370 { 371 const std::string* value = 372 std::get_if<std::string>( 373 &property.second); 374 if (value != nullptr) 375 { 376 asyncResp->res.jsonValue[propertyName] = 377 *value; 378 } 379 } 380 } 381 asyncResp->res.jsonValue["Name"] = chassisId; 382 asyncResp->res.jsonValue["Id"] = chassisId; 383 asyncResp->res.jsonValue["Thermal"] = { 384 {"@odata.id", "/redfish/v1/Chassis/" + 385 chassisId + "/Thermal"}}; 386 // Power object 387 asyncResp->res.jsonValue["Power"] = { 388 {"@odata.id", "/redfish/v1/Chassis/" + 389 chassisId + "/Power"}}; 390 // SensorCollection 391 asyncResp->res.jsonValue["Sensors"] = { 392 {"@odata.id", "/redfish/v1/Chassis/" + 393 chassisId + "/Sensors"}}; 394 asyncResp->res.jsonValue["Status"] = { 395 {"State", "Enabled"}, 396 }; 397 398 asyncResp->res 399 .jsonValue["Links"]["ComputerSystems"] = { 400 {{"@odata.id", "/redfish/v1/Systems/system"}}}; 401 asyncResp->res.jsonValue["Links"]["ManagedBy"] = { 402 {{"@odata.id", "/redfish/v1/Managers/bmc"}}}; 403 getChassisState(asyncResp); 404 }, 405 connectionName, path, "org.freedesktop.DBus.Properties", 406 "GetAll", 407 "xyz.openbmc_project.Inventory.Decorator.Asset"); 408 return; 409 } 410 411 // Couldn't find an object with that name. return an error 412 messages::resourceNotFound( 413 asyncResp->res, "#Chassis.v1_10_0.Chassis", chassisId); 414 }, 415 "xyz.openbmc_project.ObjectMapper", 416 "/xyz/openbmc_project/object_mapper", 417 "xyz.openbmc_project.ObjectMapper", "GetSubTree", 418 "/xyz/openbmc_project/inventory", 0, interfaces); 419 420 getPhysicalSecurityData(asyncResp); 421 } 422 423 void doPatch(crow::Response& res, const crow::Request& req, 424 const std::vector<std::string>& params) override 425 { 426 std::optional<std::string> indicatorLed; 427 auto asyncResp = std::make_shared<AsyncResp>(res); 428 429 if (params.size() != 1) 430 { 431 return; 432 } 433 434 if (!json_util::readJson(req, res, "IndicatorLED", indicatorLed)) 435 { 436 return; 437 } 438 439 if (!indicatorLed) 440 { 441 return; // delete this when we support more patch properties 442 } 443 444 const std::array<const char*, 2> interfaces = { 445 "xyz.openbmc_project.Inventory.Item.Board", 446 "xyz.openbmc_project.Inventory.Item.Chassis"}; 447 448 const std::string& chassisId = params[0]; 449 450 crow::connections::systemBus->async_method_call( 451 [asyncResp, chassisId, indicatorLed]( 452 const boost::system::error_code ec, 453 const crow::openbmc_mapper::GetSubTreeType& subtree) { 454 if (ec) 455 { 456 messages::internalError(asyncResp->res); 457 return; 458 } 459 460 // Iterate over all retrieved ObjectPaths. 461 for (const std::pair< 462 std::string, 463 std::vector< 464 std::pair<std::string, std::vector<std::string>>>>& 465 object : subtree) 466 { 467 const std::string& path = object.first; 468 const std::vector< 469 std::pair<std::string, std::vector<std::string>>>& 470 connectionNames = object.second; 471 472 if (!boost::ends_with(path, chassisId)) 473 { 474 continue; 475 } 476 477 if (connectionNames.size() < 1) 478 { 479 BMCWEB_LOG_ERROR << "Got 0 Connection names"; 480 continue; 481 } 482 483 const std::vector<std::string>& interfaces3 = 484 connectionNames[0].second; 485 486 if (indicatorLed) 487 { 488 const std::array<const char*, 2> hasIndicatorLed = { 489 "xyz.openbmc_project.Inventory.Item.Panel", 490 "xyz.openbmc_project.Inventory.Item.Board." 491 "Motherboard"}; 492 bool indicatorChassis = false; 493 for (const char* interface : hasIndicatorLed) 494 { 495 if (std::find(interfaces3.begin(), 496 interfaces3.end(), 497 interface) != interfaces3.end()) 498 { 499 indicatorChassis = true; 500 break; 501 } 502 } 503 if (indicatorChassis) 504 { 505 setIndicatorLedState(asyncResp, 506 std::move(*indicatorLed)); 507 } 508 else 509 { 510 messages::propertyUnknown(asyncResp->res, 511 "IndicatorLED"); 512 } 513 } 514 return; 515 } 516 517 messages::resourceNotFound( 518 asyncResp->res, "#Chassis.v1_10_0.Chassis", chassisId); 519 }, 520 "xyz.openbmc_project.ObjectMapper", 521 "/xyz/openbmc_project/object_mapper", 522 "xyz.openbmc_project.ObjectMapper", "GetSubTree", 523 "/xyz/openbmc_project/inventory", 0, interfaces); 524 } 525 }; 526 527 inline void doChassisPowerCycle(std::shared_ptr<AsyncResp> asyncResp) 528 { 529 const char* processName = "xyz.openbmc_project.State.Chassis"; 530 const char* objectPath = "/xyz/openbmc_project/state/chassis0"; 531 const char* interfaceName = "xyz.openbmc_project.State.Chassis"; 532 const char* destProperty = "RequestedPowerTransition"; 533 const std::string propertyValue = 534 "xyz.openbmc_project.State.Chassis.Transition.PowerCycle"; 535 536 crow::connections::systemBus->async_method_call( 537 [asyncResp](const boost::system::error_code ec) { 538 // Use "Set" method to set the property value. 539 if (ec) 540 { 541 BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec; 542 messages::internalError(asyncResp->res); 543 return; 544 } 545 546 messages::success(asyncResp->res); 547 }, 548 processName, objectPath, "org.freedesktop.DBus.Properties", "Set", 549 interfaceName, destProperty, std::variant<std::string>{propertyValue}); 550 } 551 552 /** 553 * ChassisResetAction class supports the POST method for the Reset 554 * action. 555 */ 556 class ChassisResetAction : public Node 557 { 558 public: 559 ChassisResetAction(App& app) : 560 Node(app, "/redfish/v1/Chassis/<str>/Actions/Chassis.Reset/", 561 std::string()) 562 { 563 entityPrivileges = { 564 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 565 } 566 567 private: 568 /** 569 * Function handles POST method request. 570 * Analyzes POST body before sending Reset request data to D-Bus. 571 */ 572 void doPost(crow::Response& res, const crow::Request& req, 573 const std::vector<std::string>&) override 574 { 575 BMCWEB_LOG_DEBUG << "Post Chassis Reset."; 576 577 std::string resetType; 578 auto asyncResp = std::make_shared<AsyncResp>(res); 579 580 if (!json_util::readJson(req, asyncResp->res, "ResetType", resetType)) 581 { 582 return; 583 } 584 585 if (resetType != "PowerCycle") 586 { 587 BMCWEB_LOG_DEBUG << "Invalid property value for ResetType: " 588 << resetType; 589 messages::actionParameterNotSupported(asyncResp->res, resetType, 590 "ResetType"); 591 592 return; 593 } 594 doChassisPowerCycle(asyncResp); 595 } 596 }; 597 598 /** 599 * ChassisResetActionInfo derived class for delivering Chassis 600 * ResetType AllowableValues using ResetInfo schema. 601 */ 602 class ChassisResetActionInfo : public Node 603 { 604 public: 605 /* 606 * Default Constructor 607 */ 608 ChassisResetActionInfo(App& app) : 609 Node(app, "/redfish/v1/Chassis/<str>/ResetActionInfo/", std::string()) 610 { 611 entityPrivileges = { 612 {boost::beast::http::verb::get, {{"Login"}}}, 613 {boost::beast::http::verb::head, {{"Login"}}}, 614 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}}, 615 {boost::beast::http::verb::put, {{"ConfigureComponents"}}}, 616 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}}, 617 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}}; 618 } 619 620 private: 621 /** 622 * Functions triggers appropriate requests on DBus 623 */ 624 void doGet(crow::Response& res, const crow::Request&, 625 const std::vector<std::string>& params) override 626 { 627 if (params.size() != 1) 628 { 629 messages::internalError(res); 630 res.end(); 631 return; 632 } 633 const std::string& chassisId = params[0]; 634 635 res.jsonValue = {{"@odata.type", "#ActionInfo.v1_1_2.ActionInfo"}, 636 {"@odata.id", "/redfish/v1/Chassis/" + chassisId + 637 "/ResetActionInfo"}, 638 {"Name", "Reset Action Info"}, 639 {"Id", "ResetActionInfo"}, 640 {"Parameters", 641 {{{"Name", "ResetType"}, 642 {"Required", true}, 643 {"DataType", "String"}, 644 {"AllowableValues", {"PowerCycle"}}}}}}; 645 res.end(); 646 } 647 }; 648 649 } // namespace redfish 650