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 "redfish_util.hpp" 20 21 #include <app.hpp> 22 #include <boost/algorithm/string/replace.hpp> 23 #include <boost/date_time.hpp> 24 #include <dbus_utility.hpp> 25 #include <registries/privilege_registry.hpp> 26 #include <utils/fw_utils.hpp> 27 #include <utils/systemd_utils.hpp> 28 29 #include <cstdint> 30 #include <memory> 31 #include <sstream> 32 #include <variant> 33 34 namespace redfish 35 { 36 37 /** 38 * Function reboots the BMC. 39 * 40 * @param[in] asyncResp - Shared pointer for completing asynchronous calls 41 */ 42 inline void 43 doBMCGracefulRestart(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) 44 { 45 const char* processName = "xyz.openbmc_project.State.BMC"; 46 const char* objectPath = "/xyz/openbmc_project/state/bmc0"; 47 const char* interfaceName = "xyz.openbmc_project.State.BMC"; 48 const std::string& propertyValue = 49 "xyz.openbmc_project.State.BMC.Transition.Reboot"; 50 const char* destProperty = "RequestedBMCTransition"; 51 52 // Create the D-Bus variant for D-Bus call. 53 dbus::utility::DbusVariantType dbusPropertyValue(propertyValue); 54 55 crow::connections::systemBus->async_method_call( 56 [asyncResp](const boost::system::error_code ec) { 57 // Use "Set" method to set the property value. 58 if (ec) 59 { 60 BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec; 61 messages::internalError(asyncResp->res); 62 return; 63 } 64 65 messages::success(asyncResp->res); 66 }, 67 processName, objectPath, "org.freedesktop.DBus.Properties", "Set", 68 interfaceName, destProperty, dbusPropertyValue); 69 } 70 71 inline void 72 doBMCForceRestart(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) 73 { 74 const char* processName = "xyz.openbmc_project.State.BMC"; 75 const char* objectPath = "/xyz/openbmc_project/state/bmc0"; 76 const char* interfaceName = "xyz.openbmc_project.State.BMC"; 77 const std::string& propertyValue = 78 "xyz.openbmc_project.State.BMC.Transition.HardReboot"; 79 const char* destProperty = "RequestedBMCTransition"; 80 81 // Create the D-Bus variant for D-Bus call. 82 dbus::utility::DbusVariantType dbusPropertyValue(propertyValue); 83 84 crow::connections::systemBus->async_method_call( 85 [asyncResp](const boost::system::error_code ec) { 86 // Use "Set" method to set the property value. 87 if (ec) 88 { 89 BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec; 90 messages::internalError(asyncResp->res); 91 return; 92 } 93 94 messages::success(asyncResp->res); 95 }, 96 processName, objectPath, "org.freedesktop.DBus.Properties", "Set", 97 interfaceName, destProperty, dbusPropertyValue); 98 } 99 100 /** 101 * ManagerResetAction class supports the POST method for the Reset (reboot) 102 * action. 103 */ 104 inline void requestRoutesManagerResetAction(App& app) 105 { 106 /** 107 * Function handles POST method request. 108 * Analyzes POST body before sending Reset (Reboot) request data to D-Bus. 109 * OpenBMC supports ResetType "GracefulRestart" and "ForceRestart". 110 */ 111 112 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/Actions/Manager.Reset/") 113 .privileges(redfish::privileges::postManager) 114 .methods(boost::beast::http::verb::post)( 115 [](const crow::Request& req, 116 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 117 BMCWEB_LOG_DEBUG << "Post Manager Reset."; 118 119 std::string resetType; 120 121 if (!json_util::readJson(req, asyncResp->res, "ResetType", 122 resetType)) 123 { 124 return; 125 } 126 127 if (resetType == "GracefulRestart") 128 { 129 BMCWEB_LOG_DEBUG << "Proceeding with " << resetType; 130 doBMCGracefulRestart(asyncResp); 131 return; 132 } 133 if (resetType == "ForceRestart") 134 { 135 BMCWEB_LOG_DEBUG << "Proceeding with " << resetType; 136 doBMCForceRestart(asyncResp); 137 return; 138 } 139 BMCWEB_LOG_DEBUG << "Invalid property value for ResetType: " 140 << resetType; 141 messages::actionParameterNotSupported(asyncResp->res, resetType, 142 "ResetType"); 143 144 return; 145 }); 146 } 147 148 /** 149 * ManagerResetToDefaultsAction class supports POST method for factory reset 150 * action. 151 */ 152 inline void requestRoutesManagerResetToDefaultsAction(App& app) 153 { 154 155 /** 156 * Function handles ResetToDefaults POST method request. 157 * 158 * Analyzes POST body message and factory resets BMC by calling 159 * BMC code updater factory reset followed by a BMC reboot. 160 * 161 * BMC code updater factory reset wipes the whole BMC read-write 162 * filesystem which includes things like the network settings. 163 * 164 * OpenBMC only supports ResetToDefaultsType "ResetAll". 165 */ 166 167 BMCWEB_ROUTE(app, 168 "/redfish/v1/Managers/bmc/Actions/Manager.ResetToDefaults/") 169 .privileges(redfish::privileges::postManager) 170 .methods(boost::beast::http::verb::post)( 171 [](const crow::Request& req, 172 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 173 BMCWEB_LOG_DEBUG << "Post ResetToDefaults."; 174 175 std::string resetType; 176 177 if (!json_util::readJson(req, asyncResp->res, 178 "ResetToDefaultsType", resetType)) 179 { 180 BMCWEB_LOG_DEBUG << "Missing property ResetToDefaultsType."; 181 182 messages::actionParameterMissing(asyncResp->res, 183 "ResetToDefaults", 184 "ResetToDefaultsType"); 185 return; 186 } 187 188 if (resetType != "ResetAll") 189 { 190 BMCWEB_LOG_DEBUG 191 << "Invalid property value for ResetToDefaultsType: " 192 << resetType; 193 messages::actionParameterNotSupported( 194 asyncResp->res, resetType, "ResetToDefaultsType"); 195 return; 196 } 197 198 crow::connections::systemBus->async_method_call( 199 [asyncResp](const boost::system::error_code ec) { 200 if (ec) 201 { 202 BMCWEB_LOG_DEBUG << "Failed to ResetToDefaults: " 203 << ec; 204 messages::internalError(asyncResp->res); 205 return; 206 } 207 // Factory Reset doesn't actually happen until a reboot 208 // Can't erase what the BMC is running on 209 doBMCGracefulRestart(asyncResp); 210 }, 211 "xyz.openbmc_project.Software.BMC.Updater", 212 "/xyz/openbmc_project/software", 213 "xyz.openbmc_project.Common.FactoryReset", "Reset"); 214 }); 215 } 216 217 /** 218 * ManagerResetActionInfo derived class for delivering Manager 219 * ResetType AllowableValues using ResetInfo schema. 220 */ 221 inline void requestRoutesManagerResetActionInfo(App& app) 222 { 223 /** 224 * Functions triggers appropriate requests on DBus 225 */ 226 227 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/ResetActionInfo/") 228 .privileges(redfish::privileges::getActionInfo) 229 .methods(boost::beast::http::verb::get)( 230 [](const crow::Request&, 231 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 232 asyncResp->res.jsonValue = { 233 {"@odata.type", "#ActionInfo.v1_1_2.ActionInfo"}, 234 {"@odata.id", "/redfish/v1/Managers/bmc/ResetActionInfo"}, 235 {"Name", "Reset Action Info"}, 236 {"Id", "ResetActionInfo"}, 237 {"Parameters", 238 {{{"Name", "ResetType"}, 239 {"Required", true}, 240 {"DataType", "String"}, 241 {"AllowableValues", 242 {"GracefulRestart", "ForceRestart"}}}}}}; 243 }); 244 } 245 246 static constexpr const char* objectManagerIface = 247 "org.freedesktop.DBus.ObjectManager"; 248 static constexpr const char* pidConfigurationIface = 249 "xyz.openbmc_project.Configuration.Pid"; 250 static constexpr const char* pidZoneConfigurationIface = 251 "xyz.openbmc_project.Configuration.Pid.Zone"; 252 static constexpr const char* stepwiseConfigurationIface = 253 "xyz.openbmc_project.Configuration.Stepwise"; 254 static constexpr const char* thermalModeIface = 255 "xyz.openbmc_project.Control.ThermalMode"; 256 257 inline void 258 asyncPopulatePid(const std::string& connection, const std::string& path, 259 const std::string& currentProfile, 260 const std::vector<std::string>& supportedProfiles, 261 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) 262 { 263 264 crow::connections::systemBus->async_method_call( 265 [asyncResp, currentProfile, supportedProfiles]( 266 const boost::system::error_code ec, 267 const dbus::utility::ManagedObjectType& managedObj) { 268 if (ec) 269 { 270 BMCWEB_LOG_ERROR << ec; 271 asyncResp->res.jsonValue.clear(); 272 messages::internalError(asyncResp->res); 273 return; 274 } 275 nlohmann::json& configRoot = 276 asyncResp->res.jsonValue["Oem"]["OpenBmc"]["Fan"]; 277 nlohmann::json& fans = configRoot["FanControllers"]; 278 fans["@odata.type"] = "#OemManager.FanControllers"; 279 fans["@odata.id"] = 280 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanControllers"; 281 282 nlohmann::json& pids = configRoot["PidControllers"]; 283 pids["@odata.type"] = "#OemManager.PidControllers"; 284 pids["@odata.id"] = 285 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/PidControllers"; 286 287 nlohmann::json& stepwise = configRoot["StepwiseControllers"]; 288 stepwise["@odata.type"] = "#OemManager.StepwiseControllers"; 289 stepwise["@odata.id"] = 290 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/StepwiseControllers"; 291 292 nlohmann::json& zones = configRoot["FanZones"]; 293 zones["@odata.id"] = 294 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones"; 295 zones["@odata.type"] = "#OemManager.FanZones"; 296 configRoot["@odata.id"] = 297 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan"; 298 configRoot["@odata.type"] = "#OemManager.Fan"; 299 configRoot["Profile@Redfish.AllowableValues"] = supportedProfiles; 300 301 if (!currentProfile.empty()) 302 { 303 configRoot["Profile"] = currentProfile; 304 } 305 BMCWEB_LOG_ERROR << "profile = " << currentProfile << " !"; 306 307 for (const auto& pathPair : managedObj) 308 { 309 for (const auto& intfPair : pathPair.second) 310 { 311 if (intfPair.first != pidConfigurationIface && 312 intfPair.first != pidZoneConfigurationIface && 313 intfPair.first != stepwiseConfigurationIface) 314 { 315 continue; 316 } 317 318 std::string name; 319 320 for (const std::pair<std::string, 321 dbus::utility::DbusVariantType>& 322 propPair : intfPair.second) 323 { 324 if (propPair.first == "Name") 325 { 326 const std::string* namePtr = 327 std::get_if<std::string>(&propPair.second); 328 if (namePtr == nullptr) 329 { 330 BMCWEB_LOG_ERROR << "Pid Name Field illegal"; 331 messages::internalError(asyncResp->res); 332 return; 333 } 334 std::string name = *namePtr; 335 dbus::utility::escapePathForDbus(name); 336 } 337 else if (propPair.first == "Profiles") 338 { 339 const std::vector<std::string>* profiles = 340 std::get_if<std::vector<std::string>>( 341 &propPair.second); 342 if (profiles == nullptr) 343 { 344 BMCWEB_LOG_ERROR 345 << "Pid Profiles Field illegal"; 346 messages::internalError(asyncResp->res); 347 return; 348 } 349 if (std::find(profiles->begin(), profiles->end(), 350 currentProfile) == profiles->end()) 351 { 352 BMCWEB_LOG_INFO 353 << name 354 << " not supported in current profile"; 355 continue; 356 } 357 } 358 } 359 nlohmann::json* config = nullptr; 360 const std::string* classPtr = nullptr; 361 362 for (const std::pair<std::string, 363 dbus::utility::DbusVariantType>& 364 propPair : intfPair.second) 365 { 366 if (propPair.first == "Class") 367 { 368 classPtr = 369 std::get_if<std::string>(&propPair.second); 370 } 371 } 372 373 if (intfPair.first == pidZoneConfigurationIface) 374 { 375 std::string chassis; 376 if (!dbus::utility::getNthStringFromPath( 377 pathPair.first.str, 5, chassis)) 378 { 379 chassis = "#IllegalValue"; 380 } 381 nlohmann::json& zone = zones[name]; 382 zone["Chassis"] = { 383 {"@odata.id", "/redfish/v1/Chassis/" + chassis}}; 384 zone["@odata.id"] = 385 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones/" + 386 name; 387 zone["@odata.type"] = "#OemManager.FanZone"; 388 config = &zone; 389 } 390 391 else if (intfPair.first == stepwiseConfigurationIface) 392 { 393 if (classPtr == nullptr) 394 { 395 BMCWEB_LOG_ERROR << "Pid Class Field illegal"; 396 messages::internalError(asyncResp->res); 397 return; 398 } 399 400 nlohmann::json& controller = stepwise[name]; 401 config = &controller; 402 403 controller["@odata.id"] = 404 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/StepwiseControllers/" + 405 name; 406 controller["@odata.type"] = 407 "#OemManager.StepwiseController"; 408 409 controller["Direction"] = *classPtr; 410 } 411 412 // pid and fans are off the same configuration 413 else if (intfPair.first == pidConfigurationIface) 414 { 415 416 if (classPtr == nullptr) 417 { 418 BMCWEB_LOG_ERROR << "Pid Class Field illegal"; 419 messages::internalError(asyncResp->res); 420 return; 421 } 422 bool isFan = *classPtr == "fan"; 423 nlohmann::json& element = 424 isFan ? fans[name] : pids[name]; 425 config = &element; 426 if (isFan) 427 { 428 element["@odata.id"] = 429 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanControllers/" + 430 name; 431 element["@odata.type"] = 432 "#OemManager.FanController"; 433 } 434 else 435 { 436 element["@odata.id"] = 437 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/PidControllers/" + 438 name; 439 element["@odata.type"] = 440 "#OemManager.PidController"; 441 } 442 } 443 else 444 { 445 BMCWEB_LOG_ERROR << "Unexpected configuration"; 446 messages::internalError(asyncResp->res); 447 return; 448 } 449 450 // used for making maps out of 2 vectors 451 const std::vector<double>* keys = nullptr; 452 const std::vector<double>* values = nullptr; 453 454 for (const auto& propertyPair : intfPair.second) 455 { 456 if (propertyPair.first == "Type" || 457 propertyPair.first == "Class" || 458 propertyPair.first == "Name") 459 { 460 continue; 461 } 462 463 // zones 464 if (intfPair.first == pidZoneConfigurationIface) 465 { 466 const double* ptr = 467 std::get_if<double>(&propertyPair.second); 468 if (ptr == nullptr) 469 { 470 BMCWEB_LOG_ERROR << "Field Illegal " 471 << propertyPair.first; 472 messages::internalError(asyncResp->res); 473 return; 474 } 475 (*config)[propertyPair.first] = *ptr; 476 } 477 478 if (intfPair.first == stepwiseConfigurationIface) 479 { 480 if (propertyPair.first == "Reading" || 481 propertyPair.first == "Output") 482 { 483 const std::vector<double>* ptr = 484 std::get_if<std::vector<double>>( 485 &propertyPair.second); 486 487 if (ptr == nullptr) 488 { 489 BMCWEB_LOG_ERROR << "Field Illegal " 490 << propertyPair.first; 491 messages::internalError(asyncResp->res); 492 return; 493 } 494 495 if (propertyPair.first == "Reading") 496 { 497 keys = ptr; 498 } 499 else 500 { 501 values = ptr; 502 } 503 if (keys && values) 504 { 505 if (keys->size() != values->size()) 506 { 507 BMCWEB_LOG_ERROR 508 << "Reading and Output size don't match "; 509 messages::internalError(asyncResp->res); 510 return; 511 } 512 nlohmann::json& steps = (*config)["Steps"]; 513 steps = nlohmann::json::array(); 514 for (size_t ii = 0; ii < keys->size(); ii++) 515 { 516 steps.push_back( 517 {{"Target", (*keys)[ii]}, 518 {"Output", (*values)[ii]}}); 519 } 520 } 521 } 522 if (propertyPair.first == "NegativeHysteresis" || 523 propertyPair.first == "PositiveHysteresis") 524 { 525 const double* ptr = 526 std::get_if<double>(&propertyPair.second); 527 if (ptr == nullptr) 528 { 529 BMCWEB_LOG_ERROR << "Field Illegal " 530 << propertyPair.first; 531 messages::internalError(asyncResp->res); 532 return; 533 } 534 (*config)[propertyPair.first] = *ptr; 535 } 536 } 537 538 // pid and fans are off the same configuration 539 if (intfPair.first == pidConfigurationIface || 540 intfPair.first == stepwiseConfigurationIface) 541 { 542 543 if (propertyPair.first == "Zones") 544 { 545 const std::vector<std::string>* inputs = 546 std::get_if<std::vector<std::string>>( 547 &propertyPair.second); 548 549 if (inputs == nullptr) 550 { 551 BMCWEB_LOG_ERROR 552 << "Zones Pid Field Illegal"; 553 messages::internalError(asyncResp->res); 554 return; 555 } 556 auto& data = (*config)[propertyPair.first]; 557 data = nlohmann::json::array(); 558 for (std::string itemCopy : *inputs) 559 { 560 dbus::utility::escapePathForDbus(itemCopy); 561 data.push_back( 562 {{"@odata.id", 563 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones/" + 564 itemCopy}}); 565 } 566 } 567 // todo(james): may never happen, but this 568 // assumes configuration data referenced in the 569 // PID config is provided by the same daemon, we 570 // could add another loop to cover all cases, 571 // but I'm okay kicking this can down the road a 572 // bit 573 574 else if (propertyPair.first == "Inputs" || 575 propertyPair.first == "Outputs") 576 { 577 auto& data = (*config)[propertyPair.first]; 578 const std::vector<std::string>* inputs = 579 std::get_if<std::vector<std::string>>( 580 &propertyPair.second); 581 582 if (inputs == nullptr) 583 { 584 BMCWEB_LOG_ERROR << "Field Illegal " 585 << propertyPair.first; 586 messages::internalError(asyncResp->res); 587 return; 588 } 589 data = *inputs; 590 } 591 else if (propertyPair.first == "SetPointOffset") 592 { 593 const std::string* ptr = 594 std::get_if<std::string>( 595 &propertyPair.second); 596 597 if (ptr == nullptr) 598 { 599 BMCWEB_LOG_ERROR << "Field Illegal " 600 << propertyPair.first; 601 messages::internalError(asyncResp->res); 602 return; 603 } 604 // translate from dbus to redfish 605 if (*ptr == "WarningHigh") 606 { 607 (*config)["SetPointOffset"] = 608 "UpperThresholdNonCritical"; 609 } 610 else if (*ptr == "WarningLow") 611 { 612 (*config)["SetPointOffset"] = 613 "LowerThresholdNonCritical"; 614 } 615 else if (*ptr == "CriticalHigh") 616 { 617 (*config)["SetPointOffset"] = 618 "UpperThresholdCritical"; 619 } 620 else if (*ptr == "CriticalLow") 621 { 622 (*config)["SetPointOffset"] = 623 "LowerThresholdCritical"; 624 } 625 else 626 { 627 BMCWEB_LOG_ERROR << "Value Illegal " 628 << *ptr; 629 messages::internalError(asyncResp->res); 630 return; 631 } 632 } 633 // doubles 634 else if (propertyPair.first == 635 "FFGainCoefficient" || 636 propertyPair.first == "FFOffCoefficient" || 637 propertyPair.first == "ICoefficient" || 638 propertyPair.first == "ILimitMax" || 639 propertyPair.first == "ILimitMin" || 640 propertyPair.first == 641 "PositiveHysteresis" || 642 propertyPair.first == 643 "NegativeHysteresis" || 644 propertyPair.first == "OutLimitMax" || 645 propertyPair.first == "OutLimitMin" || 646 propertyPair.first == "PCoefficient" || 647 propertyPair.first == "SetPoint" || 648 propertyPair.first == "SlewNeg" || 649 propertyPair.first == "SlewPos") 650 { 651 const double* ptr = 652 std::get_if<double>(&propertyPair.second); 653 if (ptr == nullptr) 654 { 655 BMCWEB_LOG_ERROR << "Field Illegal " 656 << propertyPair.first; 657 messages::internalError(asyncResp->res); 658 return; 659 } 660 (*config)[propertyPair.first] = *ptr; 661 } 662 } 663 } 664 } 665 } 666 }, 667 connection, path, objectManagerIface, "GetManagedObjects"); 668 } 669 670 enum class CreatePIDRet 671 { 672 fail, 673 del, 674 patch 675 }; 676 677 inline bool 678 getZonesFromJsonReq(const std::shared_ptr<bmcweb::AsyncResp>& response, 679 std::vector<nlohmann::json>& config, 680 std::vector<std::string>& zones) 681 { 682 if (config.empty()) 683 { 684 BMCWEB_LOG_ERROR << "Empty Zones"; 685 messages::propertyValueFormatError(response->res, 686 nlohmann::json::array(), "Zones"); 687 return false; 688 } 689 for (auto& odata : config) 690 { 691 std::string path; 692 if (!redfish::json_util::readJson(odata, response->res, "@odata.id", 693 path)) 694 { 695 return false; 696 } 697 std::string input; 698 699 // 8 below comes from 700 // /redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones/Left 701 // 0 1 2 3 4 5 6 7 8 702 if (!dbus::utility::getNthStringFromPath(path, 8, input)) 703 { 704 BMCWEB_LOG_ERROR << "Got invalid path " << path; 705 BMCWEB_LOG_ERROR << "Illegal Type Zones"; 706 messages::propertyValueFormatError(response->res, odata.dump(), 707 "Zones"); 708 return false; 709 } 710 boost::replace_all(input, "_", " "); 711 zones.emplace_back(std::move(input)); 712 } 713 return true; 714 } 715 716 inline const dbus::utility::ManagedObjectType::value_type* 717 findChassis(const dbus::utility::ManagedObjectType& managedObj, 718 const std::string& value, std::string& chassis) 719 { 720 BMCWEB_LOG_DEBUG << "Find Chassis: " << value << "\n"; 721 722 std::string escaped = boost::replace_all_copy(value, " ", "_"); 723 escaped = "/" + escaped; 724 auto it = std::find_if( 725 managedObj.begin(), managedObj.end(), [&escaped](const auto& obj) { 726 if (boost::algorithm::ends_with(obj.first.str, escaped)) 727 { 728 BMCWEB_LOG_DEBUG << "Matched " << obj.first.str << "\n"; 729 return true; 730 } 731 return false; 732 }); 733 734 if (it == managedObj.end()) 735 { 736 return nullptr; 737 } 738 // 5 comes from <chassis-name> being the 5th element 739 // /xyz/openbmc_project/inventory/system/chassis/<chassis-name> 740 if (dbus::utility::getNthStringFromPath(it->first.str, 5, chassis)) 741 { 742 return &(*it); 743 } 744 745 return nullptr; 746 } 747 748 inline CreatePIDRet createPidInterface( 749 const std::shared_ptr<bmcweb::AsyncResp>& response, const std::string& type, 750 const nlohmann::json::iterator& it, const std::string& path, 751 const dbus::utility::ManagedObjectType& managedObj, bool createNewObject, 752 boost::container::flat_map<std::string, dbus::utility::DbusVariantType>& 753 output, 754 std::string& chassis, const std::string& profile) 755 { 756 757 // common deleter 758 if (it.value() == nullptr) 759 { 760 std::string iface; 761 if (type == "PidControllers" || type == "FanControllers") 762 { 763 iface = pidConfigurationIface; 764 } 765 else if (type == "FanZones") 766 { 767 iface = pidZoneConfigurationIface; 768 } 769 else if (type == "StepwiseControllers") 770 { 771 iface = stepwiseConfigurationIface; 772 } 773 else 774 { 775 BMCWEB_LOG_ERROR << "Illegal Type " << type; 776 messages::propertyUnknown(response->res, type); 777 return CreatePIDRet::fail; 778 } 779 780 BMCWEB_LOG_DEBUG << "del " << path << " " << iface << "\n"; 781 // delete interface 782 crow::connections::systemBus->async_method_call( 783 [response, path](const boost::system::error_code ec) { 784 if (ec) 785 { 786 BMCWEB_LOG_ERROR << "Error patching " << path << ": " << ec; 787 messages::internalError(response->res); 788 return; 789 } 790 messages::success(response->res); 791 }, 792 "xyz.openbmc_project.EntityManager", path, iface, "Delete"); 793 return CreatePIDRet::del; 794 } 795 796 const dbus::utility::ManagedObjectType::value_type* managedItem = nullptr; 797 if (!createNewObject) 798 { 799 // if we aren't creating a new object, we should be able to find it on 800 // d-bus 801 managedItem = findChassis(managedObj, it.key(), chassis); 802 if (managedItem == nullptr) 803 { 804 BMCWEB_LOG_ERROR << "Failed to get chassis from config patch"; 805 messages::invalidObject(response->res, it.key()); 806 return CreatePIDRet::fail; 807 } 808 } 809 810 if (!profile.empty() && 811 (type == "PidControllers" || type == "FanControllers" || 812 type == "StepwiseControllers")) 813 { 814 if (managedItem == nullptr) 815 { 816 output["Profiles"] = std::vector<std::string>{profile}; 817 } 818 else 819 { 820 std::string interface; 821 if (type == "StepwiseControllers") 822 { 823 interface = stepwiseConfigurationIface; 824 } 825 else 826 { 827 interface = pidConfigurationIface; 828 } 829 bool ifaceFound = false; 830 for (const auto& iface : managedItem->second) 831 { 832 if (iface.first == interface) 833 { 834 ifaceFound = true; 835 for (const auto& prop : iface.second) 836 { 837 if (prop.first == "Profiles") 838 { 839 const std::vector<std::string>* curProfiles = 840 std::get_if<std::vector<std::string>>( 841 &(prop.second)); 842 if (curProfiles == nullptr) 843 { 844 BMCWEB_LOG_ERROR 845 << "Illegal profiles in managed object"; 846 messages::internalError(response->res); 847 return CreatePIDRet::fail; 848 } 849 if (std::find(curProfiles->begin(), 850 curProfiles->end(), 851 profile) == curProfiles->end()) 852 { 853 std::vector<std::string> newProfiles = 854 *curProfiles; 855 newProfiles.push_back(profile); 856 output["Profiles"] = newProfiles; 857 } 858 } 859 } 860 } 861 } 862 863 if (!ifaceFound) 864 { 865 BMCWEB_LOG_ERROR 866 << "Failed to find interface in managed object"; 867 messages::internalError(response->res); 868 return CreatePIDRet::fail; 869 } 870 } 871 } 872 873 if (type == "PidControllers" || type == "FanControllers") 874 { 875 if (createNewObject) 876 { 877 output["Class"] = type == "PidControllers" ? std::string("temp") 878 : std::string("fan"); 879 output["Type"] = std::string("Pid"); 880 } 881 882 std::optional<std::vector<nlohmann::json>> zones; 883 std::optional<std::vector<std::string>> inputs; 884 std::optional<std::vector<std::string>> outputs; 885 std::map<std::string, std::optional<double>> doubles; 886 std::optional<std::string> setpointOffset; 887 if (!redfish::json_util::readJson( 888 it.value(), response->res, "Inputs", inputs, "Outputs", outputs, 889 "Zones", zones, "FFGainCoefficient", 890 doubles["FFGainCoefficient"], "FFOffCoefficient", 891 doubles["FFOffCoefficient"], "ICoefficient", 892 doubles["ICoefficient"], "ILimitMax", doubles["ILimitMax"], 893 "ILimitMin", doubles["ILimitMin"], "OutLimitMax", 894 doubles["OutLimitMax"], "OutLimitMin", doubles["OutLimitMin"], 895 "PCoefficient", doubles["PCoefficient"], "SetPoint", 896 doubles["SetPoint"], "SetPointOffset", setpointOffset, 897 "SlewNeg", doubles["SlewNeg"], "SlewPos", doubles["SlewPos"], 898 "PositiveHysteresis", doubles["PositiveHysteresis"], 899 "NegativeHysteresis", doubles["NegativeHysteresis"])) 900 { 901 BMCWEB_LOG_ERROR 902 << "Illegal Property " 903 << it.value().dump(2, ' ', true, 904 nlohmann::json::error_handler_t::replace); 905 return CreatePIDRet::fail; 906 } 907 if (zones) 908 { 909 std::vector<std::string> zonesStr; 910 if (!getZonesFromJsonReq(response, *zones, zonesStr)) 911 { 912 BMCWEB_LOG_ERROR << "Illegal Zones"; 913 return CreatePIDRet::fail; 914 } 915 if (chassis.empty() && 916 !findChassis(managedObj, zonesStr[0], chassis)) 917 { 918 BMCWEB_LOG_ERROR << "Failed to get chassis from config patch"; 919 messages::invalidObject(response->res, it.key()); 920 return CreatePIDRet::fail; 921 } 922 923 output["Zones"] = std::move(zonesStr); 924 } 925 if (inputs || outputs) 926 { 927 std::array<std::optional<std::vector<std::string>>*, 2> containers = 928 {&inputs, &outputs}; 929 size_t index = 0; 930 for (const auto& containerPtr : containers) 931 { 932 std::optional<std::vector<std::string>>& container = 933 *containerPtr; 934 if (!container) 935 { 936 index++; 937 continue; 938 } 939 940 for (std::string& value : *container) 941 { 942 boost::replace_all(value, "_", " "); 943 } 944 std::string key; 945 if (index == 0) 946 { 947 key = "Inputs"; 948 } 949 else 950 { 951 key = "Outputs"; 952 } 953 output[key] = *container; 954 index++; 955 } 956 } 957 958 if (setpointOffset) 959 { 960 // translate between redfish and dbus names 961 if (*setpointOffset == "UpperThresholdNonCritical") 962 { 963 output["SetPointOffset"] = std::string("WarningLow"); 964 } 965 else if (*setpointOffset == "LowerThresholdNonCritical") 966 { 967 output["SetPointOffset"] = std::string("WarningHigh"); 968 } 969 else if (*setpointOffset == "LowerThresholdCritical") 970 { 971 output["SetPointOffset"] = std::string("CriticalLow"); 972 } 973 else if (*setpointOffset == "UpperThresholdCritical") 974 { 975 output["SetPointOffset"] = std::string("CriticalHigh"); 976 } 977 else 978 { 979 BMCWEB_LOG_ERROR << "Invalid setpointoffset " 980 << *setpointOffset; 981 messages::invalidObject(response->res, it.key()); 982 return CreatePIDRet::fail; 983 } 984 } 985 986 // doubles 987 for (const auto& pairs : doubles) 988 { 989 if (!pairs.second) 990 { 991 continue; 992 } 993 BMCWEB_LOG_DEBUG << pairs.first << " = " << *pairs.second; 994 output[pairs.first] = *(pairs.second); 995 } 996 } 997 998 else if (type == "FanZones") 999 { 1000 output["Type"] = std::string("Pid.Zone"); 1001 1002 std::optional<nlohmann::json> chassisContainer; 1003 std::optional<double> failSafePercent; 1004 std::optional<double> minThermalOutput; 1005 if (!redfish::json_util::readJson(it.value(), response->res, "Chassis", 1006 chassisContainer, "FailSafePercent", 1007 failSafePercent, "MinThermalOutput", 1008 minThermalOutput)) 1009 { 1010 BMCWEB_LOG_ERROR 1011 << "Illegal Property " 1012 << it.value().dump(2, ' ', true, 1013 nlohmann::json::error_handler_t::replace); 1014 return CreatePIDRet::fail; 1015 } 1016 1017 if (chassisContainer) 1018 { 1019 1020 std::string chassisId; 1021 if (!redfish::json_util::readJson(*chassisContainer, response->res, 1022 "@odata.id", chassisId)) 1023 { 1024 BMCWEB_LOG_ERROR 1025 << "Illegal Property " 1026 << chassisContainer->dump( 1027 2, ' ', true, 1028 nlohmann::json::error_handler_t::replace); 1029 return CreatePIDRet::fail; 1030 } 1031 1032 // /redfish/v1/chassis/chassis_name/ 1033 if (!dbus::utility::getNthStringFromPath(chassisId, 3, chassis)) 1034 { 1035 BMCWEB_LOG_ERROR << "Got invalid path " << chassisId; 1036 messages::invalidObject(response->res, chassisId); 1037 return CreatePIDRet::fail; 1038 } 1039 } 1040 if (minThermalOutput) 1041 { 1042 output["MinThermalOutput"] = *minThermalOutput; 1043 } 1044 if (failSafePercent) 1045 { 1046 output["FailSafePercent"] = *failSafePercent; 1047 } 1048 } 1049 else if (type == "StepwiseControllers") 1050 { 1051 output["Type"] = std::string("Stepwise"); 1052 1053 std::optional<std::vector<nlohmann::json>> zones; 1054 std::optional<std::vector<nlohmann::json>> steps; 1055 std::optional<std::vector<std::string>> inputs; 1056 std::optional<double> positiveHysteresis; 1057 std::optional<double> negativeHysteresis; 1058 std::optional<std::string> direction; // upper clipping curve vs lower 1059 if (!redfish::json_util::readJson( 1060 it.value(), response->res, "Zones", zones, "Steps", steps, 1061 "Inputs", inputs, "PositiveHysteresis", positiveHysteresis, 1062 "NegativeHysteresis", negativeHysteresis, "Direction", 1063 direction)) 1064 { 1065 BMCWEB_LOG_ERROR 1066 << "Illegal Property " 1067 << it.value().dump(2, ' ', true, 1068 nlohmann::json::error_handler_t::replace); 1069 return CreatePIDRet::fail; 1070 } 1071 1072 if (zones) 1073 { 1074 std::vector<std::string> zonesStrs; 1075 if (!getZonesFromJsonReq(response, *zones, zonesStrs)) 1076 { 1077 BMCWEB_LOG_ERROR << "Illegal Zones"; 1078 return CreatePIDRet::fail; 1079 } 1080 if (chassis.empty() && 1081 !findChassis(managedObj, zonesStrs[0], chassis)) 1082 { 1083 BMCWEB_LOG_ERROR << "Failed to get chassis from config patch"; 1084 messages::invalidObject(response->res, it.key()); 1085 return CreatePIDRet::fail; 1086 } 1087 output["Zones"] = std::move(zonesStrs); 1088 } 1089 if (steps) 1090 { 1091 std::vector<double> readings; 1092 std::vector<double> outputs; 1093 for (auto& step : *steps) 1094 { 1095 double target = 0.0; 1096 double out = 0.0; 1097 1098 if (!redfish::json_util::readJson(step, response->res, "Target", 1099 target, "Output", out)) 1100 { 1101 BMCWEB_LOG_ERROR 1102 << "Illegal Property " 1103 << it.value().dump( 1104 2, ' ', true, 1105 nlohmann::json::error_handler_t::replace); 1106 return CreatePIDRet::fail; 1107 } 1108 readings.emplace_back(target); 1109 outputs.emplace_back(out); 1110 } 1111 output["Reading"] = std::move(readings); 1112 output["Output"] = std::move(outputs); 1113 } 1114 if (inputs) 1115 { 1116 for (std::string& value : *inputs) 1117 { 1118 boost::replace_all(value, "_", " "); 1119 } 1120 output["Inputs"] = std::move(*inputs); 1121 } 1122 if (negativeHysteresis) 1123 { 1124 output["NegativeHysteresis"] = *negativeHysteresis; 1125 } 1126 if (positiveHysteresis) 1127 { 1128 output["PositiveHysteresis"] = *positiveHysteresis; 1129 } 1130 if (direction) 1131 { 1132 constexpr const std::array<const char*, 2> allowedDirections = { 1133 "Ceiling", "Floor"}; 1134 if (std::find(allowedDirections.begin(), allowedDirections.end(), 1135 *direction) == allowedDirections.end()) 1136 { 1137 messages::propertyValueTypeError(response->res, "Direction", 1138 *direction); 1139 return CreatePIDRet::fail; 1140 } 1141 output["Class"] = *direction; 1142 } 1143 } 1144 else 1145 { 1146 BMCWEB_LOG_ERROR << "Illegal Type " << type; 1147 messages::propertyUnknown(response->res, type); 1148 return CreatePIDRet::fail; 1149 } 1150 return CreatePIDRet::patch; 1151 } 1152 struct GetPIDValues : std::enable_shared_from_this<GetPIDValues> 1153 { 1154 1155 GetPIDValues(const std::shared_ptr<bmcweb::AsyncResp>& asyncRespIn) : 1156 asyncResp(asyncRespIn) 1157 1158 {} 1159 1160 void run() 1161 { 1162 std::shared_ptr<GetPIDValues> self = shared_from_this(); 1163 1164 // get all configurations 1165 crow::connections::systemBus->async_method_call( 1166 [self](const boost::system::error_code ec, 1167 const crow::openbmc_mapper::GetSubTreeType& subtreeLocal) { 1168 if (ec) 1169 { 1170 BMCWEB_LOG_ERROR << ec; 1171 messages::internalError(self->asyncResp->res); 1172 return; 1173 } 1174 self->subtree = subtreeLocal; 1175 }, 1176 "xyz.openbmc_project.ObjectMapper", 1177 "/xyz/openbmc_project/object_mapper", 1178 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0, 1179 std::array<const char*, 4>{ 1180 pidConfigurationIface, pidZoneConfigurationIface, 1181 objectManagerIface, stepwiseConfigurationIface}); 1182 1183 // at the same time get the selected profile 1184 crow::connections::systemBus->async_method_call( 1185 [self](const boost::system::error_code ec, 1186 const crow::openbmc_mapper::GetSubTreeType& subtreeLocal) { 1187 if (ec || subtreeLocal.empty()) 1188 { 1189 return; 1190 } 1191 if (subtreeLocal[0].second.size() != 1) 1192 { 1193 // invalid mapper response, should never happen 1194 BMCWEB_LOG_ERROR << "GetPIDValues: Mapper Error"; 1195 messages::internalError(self->asyncResp->res); 1196 return; 1197 } 1198 1199 const std::string& path = subtreeLocal[0].first; 1200 const std::string& owner = subtreeLocal[0].second[0].first; 1201 crow::connections::systemBus->async_method_call( 1202 [path, owner, 1203 self](const boost::system::error_code ec2, 1204 const boost::container::flat_map< 1205 std::string, dbus::utility::DbusVariantType>& 1206 resp) { 1207 if (ec2) 1208 { 1209 BMCWEB_LOG_ERROR 1210 << "GetPIDValues: Can't get thermalModeIface " 1211 << path; 1212 messages::internalError(self->asyncResp->res); 1213 return; 1214 } 1215 const std::string* current = nullptr; 1216 const std::vector<std::string>* supported = nullptr; 1217 for (const auto& [key, value] : resp) 1218 { 1219 if (key == "Current") 1220 { 1221 current = std::get_if<std::string>(&value); 1222 if (current == nullptr) 1223 { 1224 BMCWEB_LOG_ERROR 1225 << "GetPIDValues: thermal mode iface invalid " 1226 << path; 1227 messages::internalError( 1228 self->asyncResp->res); 1229 return; 1230 } 1231 } 1232 if (key == "Supported") 1233 { 1234 supported = 1235 std::get_if<std::vector<std::string>>( 1236 &value); 1237 if (supported == nullptr) 1238 { 1239 BMCWEB_LOG_ERROR 1240 << "GetPIDValues: thermal mode iface invalid" 1241 << path; 1242 messages::internalError( 1243 self->asyncResp->res); 1244 return; 1245 } 1246 } 1247 } 1248 if (current == nullptr || supported == nullptr) 1249 { 1250 BMCWEB_LOG_ERROR 1251 << "GetPIDValues: thermal mode iface invalid " 1252 << path; 1253 messages::internalError(self->asyncResp->res); 1254 return; 1255 } 1256 self->currentProfile = *current; 1257 self->supportedProfiles = *supported; 1258 }, 1259 owner, path, "org.freedesktop.DBus.Properties", "GetAll", 1260 thermalModeIface); 1261 }, 1262 "xyz.openbmc_project.ObjectMapper", 1263 "/xyz/openbmc_project/object_mapper", 1264 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0, 1265 std::array<const char*, 1>{thermalModeIface}); 1266 } 1267 1268 ~GetPIDValues() 1269 { 1270 if (asyncResp->res.result() != boost::beast::http::status::ok) 1271 { 1272 return; 1273 } 1274 // create map of <connection, path to objMgr>> 1275 boost::container::flat_map<std::string, std::string> objectMgrPaths; 1276 boost::container::flat_set<std::string> calledConnections; 1277 for (const auto& pathGroup : subtree) 1278 { 1279 for (const auto& connectionGroup : pathGroup.second) 1280 { 1281 auto findConnection = 1282 calledConnections.find(connectionGroup.first); 1283 if (findConnection != calledConnections.end()) 1284 { 1285 break; 1286 } 1287 for (const std::string& interface : connectionGroup.second) 1288 { 1289 if (interface == objectManagerIface) 1290 { 1291 objectMgrPaths[connectionGroup.first] = pathGroup.first; 1292 } 1293 // this list is alphabetical, so we 1294 // should have found the objMgr by now 1295 if (interface == pidConfigurationIface || 1296 interface == pidZoneConfigurationIface || 1297 interface == stepwiseConfigurationIface) 1298 { 1299 auto findObjMgr = 1300 objectMgrPaths.find(connectionGroup.first); 1301 if (findObjMgr == objectMgrPaths.end()) 1302 { 1303 BMCWEB_LOG_DEBUG << connectionGroup.first 1304 << "Has no Object Manager"; 1305 continue; 1306 } 1307 1308 calledConnections.insert(connectionGroup.first); 1309 1310 asyncPopulatePid(findObjMgr->first, findObjMgr->second, 1311 currentProfile, supportedProfiles, 1312 asyncResp); 1313 break; 1314 } 1315 } 1316 } 1317 } 1318 } 1319 1320 GetPIDValues(const GetPIDValues&) = delete; 1321 GetPIDValues(GetPIDValues&&) = delete; 1322 GetPIDValues& operator=(const GetPIDValues&) = delete; 1323 GetPIDValues& operator=(GetPIDValues&&) = delete; 1324 1325 std::vector<std::string> supportedProfiles; 1326 std::string currentProfile; 1327 crow::openbmc_mapper::GetSubTreeType subtree; 1328 std::shared_ptr<bmcweb::AsyncResp> asyncResp; 1329 }; 1330 1331 struct SetPIDValues : std::enable_shared_from_this<SetPIDValues> 1332 { 1333 1334 SetPIDValues(const std::shared_ptr<bmcweb::AsyncResp>& asyncRespIn, 1335 nlohmann::json& data) : 1336 asyncResp(asyncRespIn) 1337 { 1338 1339 std::optional<nlohmann::json> pidControllers; 1340 std::optional<nlohmann::json> fanControllers; 1341 std::optional<nlohmann::json> fanZones; 1342 std::optional<nlohmann::json> stepwiseControllers; 1343 1344 if (!redfish::json_util::readJson( 1345 data, asyncResp->res, "PidControllers", pidControllers, 1346 "FanControllers", fanControllers, "FanZones", fanZones, 1347 "StepwiseControllers", stepwiseControllers, "Profile", profile)) 1348 { 1349 BMCWEB_LOG_ERROR 1350 << "Illegal Property " 1351 << data.dump(2, ' ', true, 1352 nlohmann::json::error_handler_t::replace); 1353 return; 1354 } 1355 configuration.emplace_back("PidControllers", std::move(pidControllers)); 1356 configuration.emplace_back("FanControllers", std::move(fanControllers)); 1357 configuration.emplace_back("FanZones", std::move(fanZones)); 1358 configuration.emplace_back("StepwiseControllers", 1359 std::move(stepwiseControllers)); 1360 } 1361 1362 SetPIDValues(const SetPIDValues&) = delete; 1363 SetPIDValues(SetPIDValues&&) = delete; 1364 SetPIDValues& operator=(const SetPIDValues&) = delete; 1365 SetPIDValues& operator=(SetPIDValues&&) = delete; 1366 1367 void run() 1368 { 1369 if (asyncResp->res.result() != boost::beast::http::status::ok) 1370 { 1371 return; 1372 } 1373 1374 std::shared_ptr<SetPIDValues> self = shared_from_this(); 1375 1376 // todo(james): might make sense to do a mapper call here if this 1377 // interface gets more traction 1378 crow::connections::systemBus->async_method_call( 1379 [self](const boost::system::error_code ec, 1380 const dbus::utility::ManagedObjectType& mObj) { 1381 if (ec) 1382 { 1383 BMCWEB_LOG_ERROR << "Error communicating to Entity Manager"; 1384 messages::internalError(self->asyncResp->res); 1385 return; 1386 } 1387 const std::array<const char*, 3> configurations = { 1388 pidConfigurationIface, pidZoneConfigurationIface, 1389 stepwiseConfigurationIface}; 1390 1391 for (const auto& [path, object] : mObj) 1392 { 1393 for (const auto& [interface, _] : object) 1394 { 1395 if (std::find(configurations.begin(), 1396 configurations.end(), 1397 interface) != configurations.end()) 1398 { 1399 self->objectCount++; 1400 break; 1401 } 1402 } 1403 } 1404 self->managedObj = mObj; 1405 }, 1406 "xyz.openbmc_project.EntityManager", "/", objectManagerIface, 1407 "GetManagedObjects"); 1408 1409 // at the same time get the profile information 1410 crow::connections::systemBus->async_method_call( 1411 [self](const boost::system::error_code ec, 1412 const crow::openbmc_mapper::GetSubTreeType& subtree) { 1413 if (ec || subtree.empty()) 1414 { 1415 return; 1416 } 1417 if (subtree[0].second.empty()) 1418 { 1419 // invalid mapper response, should never happen 1420 BMCWEB_LOG_ERROR << "SetPIDValues: Mapper Error"; 1421 messages::internalError(self->asyncResp->res); 1422 return; 1423 } 1424 1425 const std::string& path = subtree[0].first; 1426 const std::string& owner = subtree[0].second[0].first; 1427 crow::connections::systemBus->async_method_call( 1428 [self, path, owner]( 1429 const boost::system::error_code ec2, 1430 const boost::container::flat_map< 1431 std::string, dbus::utility::DbusVariantType>& r) { 1432 if (ec2) 1433 { 1434 BMCWEB_LOG_ERROR 1435 << "SetPIDValues: Can't get thermalModeIface " 1436 << path; 1437 messages::internalError(self->asyncResp->res); 1438 return; 1439 } 1440 const std::string* current = nullptr; 1441 const std::vector<std::string>* supported = nullptr; 1442 for (const auto& [key, value] : r) 1443 { 1444 if (key == "Current") 1445 { 1446 current = std::get_if<std::string>(&value); 1447 if (current == nullptr) 1448 { 1449 BMCWEB_LOG_ERROR 1450 << "SetPIDValues: thermal mode iface invalid " 1451 << path; 1452 messages::internalError( 1453 self->asyncResp->res); 1454 return; 1455 } 1456 } 1457 if (key == "Supported") 1458 { 1459 supported = 1460 std::get_if<std::vector<std::string>>( 1461 &value); 1462 if (supported == nullptr) 1463 { 1464 BMCWEB_LOG_ERROR 1465 << "SetPIDValues: thermal mode iface invalid" 1466 << path; 1467 messages::internalError( 1468 self->asyncResp->res); 1469 return; 1470 } 1471 } 1472 } 1473 if (current == nullptr || supported == nullptr) 1474 { 1475 BMCWEB_LOG_ERROR 1476 << "SetPIDValues: thermal mode iface invalid " 1477 << path; 1478 messages::internalError(self->asyncResp->res); 1479 return; 1480 } 1481 self->currentProfile = *current; 1482 self->supportedProfiles = *supported; 1483 self->profileConnection = owner; 1484 self->profilePath = path; 1485 }, 1486 owner, path, "org.freedesktop.DBus.Properties", "GetAll", 1487 thermalModeIface); 1488 }, 1489 "xyz.openbmc_project.ObjectMapper", 1490 "/xyz/openbmc_project/object_mapper", 1491 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0, 1492 std::array<const char*, 1>{thermalModeIface}); 1493 } 1494 void pidSetDone() 1495 { 1496 if (asyncResp->res.result() != boost::beast::http::status::ok) 1497 { 1498 return; 1499 } 1500 std::shared_ptr<bmcweb::AsyncResp> response = asyncResp; 1501 if (profile) 1502 { 1503 if (std::find(supportedProfiles.begin(), supportedProfiles.end(), 1504 *profile) == supportedProfiles.end()) 1505 { 1506 messages::actionParameterUnknown(response->res, "Profile", 1507 *profile); 1508 return; 1509 } 1510 currentProfile = *profile; 1511 crow::connections::systemBus->async_method_call( 1512 [response](const boost::system::error_code ec) { 1513 if (ec) 1514 { 1515 BMCWEB_LOG_ERROR << "Error patching profile" << ec; 1516 messages::internalError(response->res); 1517 } 1518 }, 1519 profileConnection, profilePath, 1520 "org.freedesktop.DBus.Properties", "Set", thermalModeIface, 1521 "Current", dbus::utility::DbusVariantType(*profile)); 1522 } 1523 1524 for (auto& containerPair : configuration) 1525 { 1526 auto& container = containerPair.second; 1527 if (!container) 1528 { 1529 continue; 1530 } 1531 BMCWEB_LOG_DEBUG << *container; 1532 1533 std::string& type = containerPair.first; 1534 1535 for (nlohmann::json::iterator it = container->begin(); 1536 it != container->end(); ++it) 1537 { 1538 const auto& name = it.key(); 1539 BMCWEB_LOG_DEBUG << "looking for " << name; 1540 1541 auto pathItr = 1542 std::find_if(managedObj.begin(), managedObj.end(), 1543 [&name](const auto& obj) { 1544 return boost::algorithm::ends_with( 1545 obj.first.str, "/" + name); 1546 }); 1547 boost::container::flat_map<std::string, 1548 dbus::utility::DbusVariantType> 1549 output; 1550 1551 output.reserve(16); // The pid interface length 1552 1553 // determines if we're patching entity-manager or 1554 // creating a new object 1555 bool createNewObject = (pathItr == managedObj.end()); 1556 BMCWEB_LOG_DEBUG << "Found = " << !createNewObject; 1557 1558 std::string iface; 1559 /* 1560 if (type == "PidControllers" || type == "FanControllers") 1561 { 1562 iface = pidConfigurationIface; 1563 if (!createNewObject && 1564 pathItr->second.find(pidConfigurationIface) == 1565 pathItr->second.end()) 1566 { 1567 createNewObject = true; 1568 } 1569 } 1570 else if (type == "FanZones") 1571 { 1572 iface = pidZoneConfigurationIface; 1573 if (!createNewObject && 1574 pathItr->second.find(pidZoneConfigurationIface) == 1575 pathItr->second.end()) 1576 { 1577 1578 createNewObject = true; 1579 } 1580 } 1581 else if (type == "StepwiseControllers") 1582 { 1583 iface = stepwiseConfigurationIface; 1584 if (!createNewObject && 1585 pathItr->second.find(stepwiseConfigurationIface) == 1586 pathItr->second.end()) 1587 { 1588 createNewObject = true; 1589 } 1590 }*/ 1591 1592 if (createNewObject && it.value() == nullptr) 1593 { 1594 // can't delete a non-existent object 1595 messages::invalidObject(response->res, name); 1596 continue; 1597 } 1598 1599 std::string path; 1600 if (pathItr != managedObj.end()) 1601 { 1602 path = pathItr->first.str; 1603 } 1604 1605 BMCWEB_LOG_DEBUG << "Create new = " << createNewObject << "\n"; 1606 1607 // arbitrary limit to avoid attacks 1608 constexpr const size_t controllerLimit = 500; 1609 if (createNewObject && objectCount >= controllerLimit) 1610 { 1611 messages::resourceExhaustion(response->res, type); 1612 continue; 1613 } 1614 1615 output["Name"] = boost::replace_all_copy(name, "_", " "); 1616 1617 std::string chassis; 1618 CreatePIDRet ret = createPidInterface( 1619 response, type, it, path, managedObj, createNewObject, 1620 output, chassis, currentProfile); 1621 if (ret == CreatePIDRet::fail) 1622 { 1623 return; 1624 } 1625 if (ret == CreatePIDRet::del) 1626 { 1627 continue; 1628 } 1629 1630 if (!createNewObject) 1631 { 1632 for (const auto& property : output) 1633 { 1634 crow::connections::systemBus->async_method_call( 1635 [response, 1636 propertyName{std::string(property.first)}]( 1637 const boost::system::error_code ec) { 1638 if (ec) 1639 { 1640 BMCWEB_LOG_ERROR << "Error patching " 1641 << propertyName << ": " 1642 << ec; 1643 messages::internalError(response->res); 1644 return; 1645 } 1646 messages::success(response->res); 1647 }, 1648 "xyz.openbmc_project.EntityManager", path, 1649 "org.freedesktop.DBus.Properties", "Set", iface, 1650 property.first, property.second); 1651 } 1652 } 1653 else 1654 { 1655 if (chassis.empty()) 1656 { 1657 BMCWEB_LOG_ERROR << "Failed to get chassis from config"; 1658 messages::invalidObject(response->res, name); 1659 return; 1660 } 1661 1662 bool foundChassis = false; 1663 for (const auto& obj : managedObj) 1664 { 1665 if (boost::algorithm::ends_with(obj.first.str, chassis)) 1666 { 1667 chassis = obj.first.str; 1668 foundChassis = true; 1669 break; 1670 } 1671 } 1672 if (!foundChassis) 1673 { 1674 BMCWEB_LOG_ERROR << "Failed to find chassis on dbus"; 1675 messages::resourceMissingAtURI( 1676 response->res, "/redfish/v1/Chassis/" + chassis); 1677 return; 1678 } 1679 1680 crow::connections::systemBus->async_method_call( 1681 [response](const boost::system::error_code ec) { 1682 if (ec) 1683 { 1684 BMCWEB_LOG_ERROR << "Error Adding Pid Object " 1685 << ec; 1686 messages::internalError(response->res); 1687 return; 1688 } 1689 messages::success(response->res); 1690 }, 1691 "xyz.openbmc_project.EntityManager", chassis, 1692 "xyz.openbmc_project.AddObject", "AddObject", output); 1693 } 1694 } 1695 } 1696 } 1697 1698 ~SetPIDValues() 1699 { 1700 try 1701 { 1702 pidSetDone(); 1703 } 1704 catch (...) 1705 { 1706 BMCWEB_LOG_CRITICAL << "pidSetDone threw exception"; 1707 } 1708 } 1709 1710 std::shared_ptr<bmcweb::AsyncResp> asyncResp; 1711 std::vector<std::pair<std::string, std::optional<nlohmann::json>>> 1712 configuration; 1713 std::optional<std::string> profile; 1714 dbus::utility::ManagedObjectType managedObj; 1715 std::vector<std::string> supportedProfiles; 1716 std::string currentProfile; 1717 std::string profileConnection; 1718 std::string profilePath; 1719 size_t objectCount = 0; 1720 }; 1721 1722 /** 1723 * @brief Retrieves BMC manager location data over DBus 1724 * 1725 * @param[in] aResp Shared pointer for completing asynchronous calls 1726 * @param[in] connectionName - service name 1727 * @param[in] path - object path 1728 * @return none 1729 */ 1730 inline void getLocation(const std::shared_ptr<bmcweb::AsyncResp>& aResp, 1731 const std::string& connectionName, 1732 const std::string& path) 1733 { 1734 BMCWEB_LOG_DEBUG << "Get BMC manager Location data."; 1735 1736 sdbusplus::asio::getProperty<std::string>( 1737 *crow::connections::systemBus, connectionName, path, 1738 "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode", 1739 [aResp](const boost::system::error_code ec, 1740 const std::string& property) { 1741 if (ec) 1742 { 1743 BMCWEB_LOG_DEBUG << "DBUS response error for " 1744 "Location"; 1745 messages::internalError(aResp->res); 1746 return; 1747 } 1748 1749 aResp->res.jsonValue["Location"]["PartLocation"]["ServiceLabel"] = 1750 property; 1751 }); 1752 } 1753 // avoid name collision systems.hpp 1754 inline void 1755 managerGetLastResetTime(const std::shared_ptr<bmcweb::AsyncResp>& aResp) 1756 { 1757 BMCWEB_LOG_DEBUG << "Getting Manager Last Reset Time"; 1758 1759 sdbusplus::asio::getProperty<uint64_t>( 1760 *crow::connections::systemBus, "xyz.openbmc_project.State.BMC", 1761 "/xyz/openbmc_project/state/bmc0", "xyz.openbmc_project.State.BMC", 1762 "LastRebootTime", 1763 [aResp](const boost::system::error_code ec, 1764 const uint64_t lastResetTime) { 1765 if (ec) 1766 { 1767 BMCWEB_LOG_DEBUG << "D-BUS response error " << ec; 1768 return; 1769 } 1770 1771 // LastRebootTime is epoch time, in milliseconds 1772 // https://github.com/openbmc/phosphor-dbus-interfaces/blob/7f9a128eb9296e926422ddc312c148b625890bb6/xyz/openbmc_project/State/BMC.interface.yaml#L19 1773 uint64_t lastResetTimeStamp = lastResetTime / 1000; 1774 1775 // Convert to ISO 8601 standard 1776 aResp->res.jsonValue["LastResetTime"] = 1777 crow::utility::getDateTimeUint(lastResetTimeStamp); 1778 }); 1779 } 1780 1781 /** 1782 * @brief Set the running firmware image 1783 * 1784 * @param[i,o] aResp - Async response object 1785 * @param[i] runningFirmwareTarget - Image to make the running image 1786 * 1787 * @return void 1788 */ 1789 inline void 1790 setActiveFirmwareImage(const std::shared_ptr<bmcweb::AsyncResp>& aResp, 1791 const std::string& runningFirmwareTarget) 1792 { 1793 // Get the Id from /redfish/v1/UpdateService/FirmwareInventory/<Id> 1794 std::string::size_type idPos = runningFirmwareTarget.rfind('/'); 1795 if (idPos == std::string::npos) 1796 { 1797 messages::propertyValueNotInList(aResp->res, runningFirmwareTarget, 1798 "@odata.id"); 1799 BMCWEB_LOG_DEBUG << "Can't parse firmware ID!"; 1800 return; 1801 } 1802 idPos++; 1803 if (idPos >= runningFirmwareTarget.size()) 1804 { 1805 messages::propertyValueNotInList(aResp->res, runningFirmwareTarget, 1806 "@odata.id"); 1807 BMCWEB_LOG_DEBUG << "Invalid firmware ID."; 1808 return; 1809 } 1810 std::string firmwareId = runningFirmwareTarget.substr(idPos); 1811 1812 // Make sure the image is valid before setting priority 1813 crow::connections::systemBus->async_method_call( 1814 [aResp, firmwareId, 1815 runningFirmwareTarget](const boost::system::error_code ec, 1816 dbus::utility::ManagedObjectType& subtree) { 1817 if (ec) 1818 { 1819 BMCWEB_LOG_DEBUG << "D-Bus response error getting objects."; 1820 messages::internalError(aResp->res); 1821 return; 1822 } 1823 1824 if (subtree.empty()) 1825 { 1826 BMCWEB_LOG_DEBUG << "Can't find image!"; 1827 messages::internalError(aResp->res); 1828 return; 1829 } 1830 1831 bool foundImage = false; 1832 for (auto& object : subtree) 1833 { 1834 const std::string& path = 1835 static_cast<const std::string&>(object.first); 1836 std::size_t idPos2 = path.rfind('/'); 1837 1838 if (idPos2 == std::string::npos) 1839 { 1840 continue; 1841 } 1842 1843 idPos2++; 1844 if (idPos2 >= path.size()) 1845 { 1846 continue; 1847 } 1848 1849 if (path.substr(idPos2) == firmwareId) 1850 { 1851 foundImage = true; 1852 break; 1853 } 1854 } 1855 1856 if (!foundImage) 1857 { 1858 messages::propertyValueNotInList( 1859 aResp->res, runningFirmwareTarget, "@odata.id"); 1860 BMCWEB_LOG_DEBUG << "Invalid firmware ID."; 1861 return; 1862 } 1863 1864 BMCWEB_LOG_DEBUG 1865 << "Setting firmware version " + firmwareId + " to priority 0."; 1866 1867 // Only support Immediate 1868 // An addition could be a Redfish Setting like 1869 // ActiveSoftwareImageApplyTime and support OnReset 1870 crow::connections::systemBus->async_method_call( 1871 [aResp](const boost::system::error_code ec) { 1872 if (ec) 1873 { 1874 BMCWEB_LOG_DEBUG << "D-Bus response error setting."; 1875 messages::internalError(aResp->res); 1876 return; 1877 } 1878 doBMCGracefulRestart(aResp); 1879 }, 1880 1881 "xyz.openbmc_project.Software.BMC.Updater", 1882 "/xyz/openbmc_project/software/" + firmwareId, 1883 "org.freedesktop.DBus.Properties", "Set", 1884 "xyz.openbmc_project.Software.RedundancyPriority", "Priority", 1885 dbus::utility::DbusVariantType(static_cast<uint8_t>(0))); 1886 }, 1887 "xyz.openbmc_project.Software.BMC.Updater", 1888 "/xyz/openbmc_project/software", "org.freedesktop.DBus.ObjectManager", 1889 "GetManagedObjects"); 1890 } 1891 1892 inline void setDateTime(std::shared_ptr<bmcweb::AsyncResp> aResp, 1893 std::string datetime) 1894 { 1895 BMCWEB_LOG_DEBUG << "Set date time: " << datetime; 1896 1897 std::stringstream stream(datetime); 1898 // Convert from ISO 8601 to boost local_time 1899 // (BMC only has time in UTC) 1900 boost::posix_time::ptime posixTime; 1901 boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); 1902 // Facet gets deleted with the stringsteam 1903 auto ifc = std::make_unique<boost::local_time::local_time_input_facet>( 1904 "%Y-%m-%d %H:%M:%S%F %ZP"); 1905 stream.imbue(std::locale(stream.getloc(), ifc.release())); 1906 1907 boost::local_time::local_date_time ldt(boost::local_time::not_a_date_time); 1908 1909 if (stream >> ldt) 1910 { 1911 posixTime = ldt.utc_time(); 1912 boost::posix_time::time_duration dur = posixTime - epoch; 1913 uint64_t durMicroSecs = static_cast<uint64_t>(dur.total_microseconds()); 1914 crow::connections::systemBus->async_method_call( 1915 [aResp{std::move(aResp)}, datetime{std::move(datetime)}]( 1916 const boost::system::error_code ec) { 1917 if (ec) 1918 { 1919 BMCWEB_LOG_DEBUG << "Failed to set elapsed time. " 1920 "DBUS response error " 1921 << ec; 1922 messages::internalError(aResp->res); 1923 return; 1924 } 1925 aResp->res.jsonValue["DateTime"] = datetime; 1926 }, 1927 "xyz.openbmc_project.Time.Manager", "/xyz/openbmc_project/time/bmc", 1928 "org.freedesktop.DBus.Properties", "Set", 1929 "xyz.openbmc_project.Time.EpochTime", "Elapsed", 1930 dbus::utility::DbusVariantType(durMicroSecs)); 1931 } 1932 else 1933 { 1934 messages::propertyValueFormatError(aResp->res, datetime, "DateTime"); 1935 return; 1936 } 1937 } 1938 1939 inline void requestRoutesManager(App& app) 1940 { 1941 std::string uuid = persistent_data::getConfig().systemUuid; 1942 1943 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/") 1944 .privileges(redfish::privileges::getManager) 1945 .methods(boost::beast::http::verb::get)([uuid](const crow::Request&, 1946 const std::shared_ptr< 1947 bmcweb::AsyncResp>& 1948 asyncResp) { 1949 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Managers/bmc"; 1950 asyncResp->res.jsonValue["@odata.type"] = 1951 "#Manager.v1_11_0.Manager"; 1952 asyncResp->res.jsonValue["Id"] = "bmc"; 1953 asyncResp->res.jsonValue["Name"] = "OpenBmc Manager"; 1954 asyncResp->res.jsonValue["Description"] = 1955 "Baseboard Management Controller"; 1956 asyncResp->res.jsonValue["PowerState"] = "On"; 1957 asyncResp->res.jsonValue["Status"] = {{"State", "Enabled"}, 1958 {"Health", "OK"}}; 1959 asyncResp->res.jsonValue["ManagerType"] = "BMC"; 1960 asyncResp->res.jsonValue["UUID"] = systemd_utils::getUuid(); 1961 asyncResp->res.jsonValue["ServiceEntryPointUUID"] = uuid; 1962 asyncResp->res.jsonValue["Model"] = 1963 "OpenBmc"; // TODO(ed), get model 1964 1965 asyncResp->res.jsonValue["LogServices"] = { 1966 {"@odata.id", "/redfish/v1/Managers/bmc/LogServices"}}; 1967 1968 asyncResp->res.jsonValue["NetworkProtocol"] = { 1969 {"@odata.id", "/redfish/v1/Managers/bmc/NetworkProtocol"}}; 1970 1971 asyncResp->res.jsonValue["EthernetInterfaces"] = { 1972 {"@odata.id", "/redfish/v1/Managers/bmc/EthernetInterfaces"}}; 1973 1974 #ifdef BMCWEB_ENABLE_VM_NBDPROXY 1975 asyncResp->res.jsonValue["VirtualMedia"] = { 1976 {"@odata.id", "/redfish/v1/Managers/bmc/VirtualMedia"}}; 1977 #endif // BMCWEB_ENABLE_VM_NBDPROXY 1978 1979 // default oem data 1980 nlohmann::json& oem = asyncResp->res.jsonValue["Oem"]; 1981 nlohmann::json& oemOpenbmc = oem["OpenBmc"]; 1982 oem["@odata.type"] = "#OemManager.Oem"; 1983 oem["@odata.id"] = "/redfish/v1/Managers/bmc#/Oem"; 1984 oemOpenbmc["@odata.type"] = "#OemManager.OpenBmc"; 1985 oemOpenbmc["@odata.id"] = "/redfish/v1/Managers/bmc#/Oem/OpenBmc"; 1986 oemOpenbmc["Certificates"] = { 1987 {"@odata.id", 1988 "/redfish/v1/Managers/bmc/Truststore/Certificates"}}; 1989 1990 // Manager.Reset (an action) can be many values, OpenBMC only 1991 // supports BMC reboot. 1992 nlohmann::json& managerReset = 1993 asyncResp->res.jsonValue["Actions"]["#Manager.Reset"]; 1994 managerReset["target"] = 1995 "/redfish/v1/Managers/bmc/Actions/Manager.Reset"; 1996 managerReset["@Redfish.ActionInfo"] = 1997 "/redfish/v1/Managers/bmc/ResetActionInfo"; 1998 1999 // ResetToDefaults (Factory Reset) has values like 2000 // PreserveNetworkAndUsers and PreserveNetwork that aren't supported 2001 // on OpenBMC 2002 nlohmann::json& resetToDefaults = 2003 asyncResp->res.jsonValue["Actions"]["#Manager.ResetToDefaults"]; 2004 resetToDefaults["target"] = 2005 "/redfish/v1/Managers/bmc/Actions/Manager.ResetToDefaults"; 2006 resetToDefaults["ResetType@Redfish.AllowableValues"] = {"ResetAll"}; 2007 2008 std::pair<std::string, std::string> redfishDateTimeOffset = 2009 crow::utility::getDateTimeOffsetNow(); 2010 2011 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first; 2012 asyncResp->res.jsonValue["DateTimeLocalOffset"] = 2013 redfishDateTimeOffset.second; 2014 2015 // TODO (Gunnar): Remove these one day since moved to ComputerSystem 2016 // Still used by OCP profiles 2017 // https://github.com/opencomputeproject/OCP-Profiles/issues/23 2018 // Fill in SerialConsole info 2019 asyncResp->res.jsonValue["SerialConsole"]["ServiceEnabled"] = true; 2020 asyncResp->res.jsonValue["SerialConsole"]["MaxConcurrentSessions"] = 2021 15; 2022 asyncResp->res.jsonValue["SerialConsole"]["ConnectTypesSupported"] = 2023 {"IPMI", "SSH"}; 2024 #ifdef BMCWEB_ENABLE_KVM 2025 // Fill in GraphicalConsole info 2026 asyncResp->res.jsonValue["GraphicalConsole"]["ServiceEnabled"] = 2027 true; 2028 asyncResp->res 2029 .jsonValue["GraphicalConsole"]["MaxConcurrentSessions"] = 4; 2030 asyncResp->res.jsonValue["GraphicalConsole"] 2031 ["ConnectTypesSupported"] = {"KVMIP"}; 2032 #endif // BMCWEB_ENABLE_KVM 2033 2034 asyncResp->res.jsonValue["Links"]["ManagerForServers@odata.count"] = 2035 1; 2036 asyncResp->res.jsonValue["Links"]["ManagerForServers"] = { 2037 {{"@odata.id", "/redfish/v1/Systems/system"}}}; 2038 2039 auto health = std::make_shared<HealthPopulate>(asyncResp); 2040 health->isManagersHealth = true; 2041 health->populate(); 2042 2043 fw_util::populateFirmwareInformation(asyncResp, fw_util::bmcPurpose, 2044 "FirmwareVersion", true); 2045 2046 managerGetLastResetTime(asyncResp); 2047 2048 auto pids = std::make_shared<GetPIDValues>(asyncResp); 2049 pids->run(); 2050 2051 getMainChassisId( 2052 asyncResp, [](const std::string& chassisId, 2053 const std::shared_ptr<bmcweb::AsyncResp>& aRsp) { 2054 aRsp->res 2055 .jsonValue["Links"]["ManagerForChassis@odata.count"] = 2056 1; 2057 aRsp->res.jsonValue["Links"]["ManagerForChassis"] = { 2058 {{"@odata.id", "/redfish/v1/Chassis/" + chassisId}}}; 2059 aRsp->res.jsonValue["Links"]["ManagerInChassis"] = { 2060 {"@odata.id", "/redfish/v1/Chassis/" + chassisId}}; 2061 }); 2062 2063 static bool started = false; 2064 2065 if (!started) 2066 { 2067 sdbusplus::asio::getProperty<double>( 2068 *crow::connections::systemBus, "org.freedesktop.systemd1", 2069 "/org/freedesktop/systemd1", 2070 "org.freedesktop.systemd1.Manager", "Progress", 2071 [asyncResp](const boost::system::error_code ec, 2072 const double& val) { 2073 if (ec) 2074 { 2075 BMCWEB_LOG_ERROR << "Error while getting progress"; 2076 messages::internalError(asyncResp->res); 2077 return; 2078 } 2079 if (val < 1.0) 2080 { 2081 asyncResp->res.jsonValue["Status"]["State"] = 2082 "Starting"; 2083 started = true; 2084 } 2085 }); 2086 } 2087 2088 crow::connections::systemBus->async_method_call( 2089 [asyncResp]( 2090 const boost::system::error_code ec, 2091 const std::vector< 2092 std::pair<std::string, 2093 std::vector<std::pair< 2094 std::string, std::vector<std::string>>>>>& 2095 subtree) { 2096 if (ec) 2097 { 2098 BMCWEB_LOG_DEBUG 2099 << "D-Bus response error on GetSubTree " << ec; 2100 return; 2101 } 2102 if (subtree.empty()) 2103 { 2104 BMCWEB_LOG_DEBUG << "Can't find bmc D-Bus object!"; 2105 return; 2106 } 2107 // Assume only 1 bmc D-Bus object 2108 // Throw an error if there is more than 1 2109 if (subtree.size() > 1) 2110 { 2111 BMCWEB_LOG_DEBUG 2112 << "Found more than 1 bmc D-Bus object!"; 2113 messages::internalError(asyncResp->res); 2114 return; 2115 } 2116 2117 if (subtree[0].first.empty() || 2118 subtree[0].second.size() != 1) 2119 { 2120 BMCWEB_LOG_DEBUG << "Error getting bmc D-Bus object!"; 2121 messages::internalError(asyncResp->res); 2122 return; 2123 } 2124 2125 const std::string& path = subtree[0].first; 2126 const std::string& connectionName = 2127 subtree[0].second[0].first; 2128 2129 for (const auto& interfaceName : 2130 subtree[0].second[0].second) 2131 { 2132 if (interfaceName == 2133 "xyz.openbmc_project.Inventory.Decorator.Asset") 2134 { 2135 crow::connections::systemBus->async_method_call( 2136 [asyncResp]( 2137 const boost::system::error_code ec, 2138 const std::vector<std::pair< 2139 std::string, 2140 dbus::utility::DbusVariantType>>& 2141 propertiesList) { 2142 if (ec) 2143 { 2144 BMCWEB_LOG_DEBUG 2145 << "Can't get bmc asset!"; 2146 return; 2147 } 2148 for (const std::pair< 2149 std::string, 2150 dbus::utility::DbusVariantType>& 2151 property : propertiesList) 2152 { 2153 const std::string& propertyName = 2154 property.first; 2155 2156 if ((propertyName == "PartNumber") || 2157 (propertyName == "SerialNumber") || 2158 (propertyName == "Manufacturer") || 2159 (propertyName == "Model") || 2160 (propertyName == "SparePartNumber")) 2161 { 2162 const std::string* value = 2163 std::get_if<std::string>( 2164 &property.second); 2165 if (value == nullptr) 2166 { 2167 // illegal property 2168 messages::internalError( 2169 asyncResp->res); 2170 return; 2171 } 2172 asyncResp->res 2173 .jsonValue[propertyName] = 2174 *value; 2175 } 2176 } 2177 }, 2178 connectionName, path, 2179 "org.freedesktop.DBus.Properties", "GetAll", 2180 "xyz.openbmc_project.Inventory.Decorator.Asset"); 2181 } 2182 else if ( 2183 interfaceName == 2184 "xyz.openbmc_project.Inventory.Decorator.LocationCode") 2185 { 2186 getLocation(asyncResp, connectionName, path); 2187 } 2188 } 2189 }, 2190 "xyz.openbmc_project.ObjectMapper", 2191 "/xyz/openbmc_project/object_mapper", 2192 "xyz.openbmc_project.ObjectMapper", "GetSubTree", 2193 "/xyz/openbmc_project/inventory", int32_t(0), 2194 std::array<const char*, 1>{ 2195 "xyz.openbmc_project.Inventory.Item.Bmc"}); 2196 }); 2197 2198 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/") 2199 .privileges(redfish::privileges::patchManager) 2200 .methods( 2201 boost::beast::http::verb:: 2202 patch)([](const crow::Request& req, 2203 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 2204 std::optional<nlohmann::json> oem; 2205 std::optional<nlohmann::json> links; 2206 std::optional<std::string> datetime; 2207 2208 if (!json_util::readJson(req, asyncResp->res, "Oem", oem, 2209 "DateTime", datetime, "Links", links)) 2210 { 2211 return; 2212 } 2213 2214 if (oem) 2215 { 2216 std::optional<nlohmann::json> openbmc; 2217 if (!redfish::json_util::readJson(*oem, asyncResp->res, 2218 "OpenBmc", openbmc)) 2219 { 2220 BMCWEB_LOG_ERROR 2221 << "Illegal Property " 2222 << oem->dump(2, ' ', true, 2223 nlohmann::json::error_handler_t::replace); 2224 return; 2225 } 2226 if (openbmc) 2227 { 2228 std::optional<nlohmann::json> fan; 2229 if (!redfish::json_util::readJson(*openbmc, asyncResp->res, 2230 "Fan", fan)) 2231 { 2232 BMCWEB_LOG_ERROR 2233 << "Illegal Property " 2234 << openbmc->dump( 2235 2, ' ', true, 2236 nlohmann::json::error_handler_t::replace); 2237 return; 2238 } 2239 if (fan) 2240 { 2241 auto pid = 2242 std::make_shared<SetPIDValues>(asyncResp, *fan); 2243 pid->run(); 2244 } 2245 } 2246 } 2247 if (links) 2248 { 2249 std::optional<nlohmann::json> activeSoftwareImage; 2250 if (!redfish::json_util::readJson(*links, asyncResp->res, 2251 "ActiveSoftwareImage", 2252 activeSoftwareImage)) 2253 { 2254 return; 2255 } 2256 if (activeSoftwareImage) 2257 { 2258 std::optional<std::string> odataId; 2259 if (!json_util::readJson(*activeSoftwareImage, 2260 asyncResp->res, "@odata.id", 2261 odataId)) 2262 { 2263 return; 2264 } 2265 2266 if (odataId) 2267 { 2268 setActiveFirmwareImage(asyncResp, *odataId); 2269 } 2270 } 2271 } 2272 if (datetime) 2273 { 2274 setDateTime(asyncResp, std::move(*datetime)); 2275 } 2276 }); 2277 } 2278 2279 inline void requestRoutesManagerCollection(App& app) 2280 { 2281 BMCWEB_ROUTE(app, "/redfish/v1/Managers/") 2282 .privileges(redfish::privileges::getManagerCollection) 2283 .methods(boost::beast::http::verb::get)( 2284 [](const crow::Request&, 2285 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) { 2286 // Collections don't include the static data added by SubRoute 2287 // because it has a duplicate entry for members 2288 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Managers"; 2289 asyncResp->res.jsonValue["@odata.type"] = 2290 "#ManagerCollection.ManagerCollection"; 2291 asyncResp->res.jsonValue["Name"] = "Manager Collection"; 2292 asyncResp->res.jsonValue["Members@odata.count"] = 1; 2293 asyncResp->res.jsonValue["Members"] = { 2294 {{"@odata.id", "/redfish/v1/Managers/bmc"}}}; 2295 }); 2296 } 2297 } // namespace redfish 2298