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 "generated/enums/action_info.hpp"
21 #include "generated/enums/chassis.hpp"
22 #include "generated/enums/resource.hpp"
23 #include "led.hpp"
24 #include "query.hpp"
25 #include "redfish_util.hpp"
26 #include "registries/privilege_registry.hpp"
27 #include "utils/collection.hpp"
28 #include "utils/dbus_utils.hpp"
29 #include "utils/json_utils.hpp"
30
31 #include <boost/system/error_code.hpp>
32 #include <boost/url/format.hpp>
33 #include <sdbusplus/asio/property.hpp>
34 #include <sdbusplus/message.hpp>
35 #include <sdbusplus/unpack_properties.hpp>
36
37 #include <array>
38 #include <ranges>
39 #include <string_view>
40
41 namespace redfish
42 {
43
44 /**
45 * @brief Retrieves resources over dbus to link to the chassis
46 *
47 * @param[in] asyncResp - Shared pointer for completing asynchronous
48 * calls
49 * @param[in] path - Chassis dbus path to look for the storage.
50 *
51 * Calls the Association endpoints on the path + "/storage" and add the link of
52 * json["Links"]["Storage@odata.count"] =
53 * {"@odata.id", "/redfish/v1/Storage/" + resourceId}
54 *
55 * @return None.
56 */
getStorageLink(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const sdbusplus::message::object_path & path)57 inline void getStorageLink(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
58 const sdbusplus::message::object_path& path)
59 {
60 sdbusplus::asio::getProperty<std::vector<std::string>>(
61 *crow::connections::systemBus, "xyz.openbmc_project.ObjectMapper",
62 (path / "storage").str, "xyz.openbmc_project.Association", "endpoints",
63 [asyncResp](const boost::system::error_code& ec,
64 const std::vector<std::string>& storageList) {
65 if (ec)
66 {
67 BMCWEB_LOG_DEBUG("getStorageLink got DBUS response error");
68 return;
69 }
70
71 nlohmann::json::array_t storages;
72 for (const std::string& storagePath : storageList)
73 {
74 std::string id =
75 sdbusplus::message::object_path(storagePath).filename();
76 if (id.empty())
77 {
78 continue;
79 }
80
81 nlohmann::json::object_t storage;
82 storage["@odata.id"] =
83 boost::urls::format("/redfish/v1/Systems/{}/Storage/{}",
84 BMCWEB_REDFISH_SYSTEM_URI_NAME, id);
85 storages.emplace_back(std::move(storage));
86 }
87 asyncResp->res.jsonValue["Links"]["Storage@odata.count"] =
88 storages.size();
89 asyncResp->res.jsonValue["Links"]["Storage"] = std::move(storages);
90 });
91 }
92
93 /**
94 * @brief Retrieves chassis state properties over dbus
95 *
96 * @param[in] asyncResp - Shared pointer for completing asynchronous calls.
97 *
98 * @return None.
99 */
getChassisState(std::shared_ptr<bmcweb::AsyncResp> asyncResp)100 inline void getChassisState(std::shared_ptr<bmcweb::AsyncResp> asyncResp)
101 {
102 // crow::connections::systemBus->async_method_call(
103 sdbusplus::asio::getProperty<std::string>(
104 *crow::connections::systemBus, "xyz.openbmc_project.State.Chassis",
105 "/xyz/openbmc_project/state/chassis0",
106 "xyz.openbmc_project.State.Chassis", "CurrentPowerState",
107 [asyncResp{std::move(asyncResp)}](const boost::system::error_code& ec,
108 const std::string& chassisState) {
109 if (ec)
110 {
111 if (ec == boost::system::errc::host_unreachable)
112 {
113 // Service not available, no error, just don't return
114 // chassis state info
115 BMCWEB_LOG_DEBUG("Service not available {}", ec);
116 return;
117 }
118 BMCWEB_LOG_DEBUG("DBUS response error {}", ec);
119 messages::internalError(asyncResp->res);
120 return;
121 }
122
123 BMCWEB_LOG_DEBUG("Chassis state: {}", chassisState);
124 // Verify Chassis State
125 if (chassisState ==
126 "xyz.openbmc_project.State.Chassis.PowerState.On")
127 {
128 asyncResp->res.jsonValue["PowerState"] =
129 resource::PowerState::On;
130 asyncResp->res.jsonValue["Status"]["State"] =
131 resource::State::Enabled;
132 }
133 else if (chassisState ==
134 "xyz.openbmc_project.State.Chassis.PowerState.Off")
135 {
136 asyncResp->res.jsonValue["PowerState"] =
137 resource::PowerState::Off;
138 asyncResp->res.jsonValue["Status"]["State"] =
139 resource::State::StandbyOffline;
140 }
141 });
142 }
143
144 /**
145 * Retrieves physical security properties over dbus
146 */
handlePhysicalSecurityGetSubTree(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const boost::system::error_code & ec,const dbus::utility::MapperGetSubTreeResponse & subtree)147 inline void handlePhysicalSecurityGetSubTree(
148 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
149 const boost::system::error_code& ec,
150 const dbus::utility::MapperGetSubTreeResponse& subtree)
151 {
152 if (ec)
153 {
154 // do not add err msg in redfish response, because this is not
155 // mandatory property
156 BMCWEB_LOG_INFO("DBUS error: no matched iface {}", ec);
157 return;
158 }
159 // Iterate over all retrieved ObjectPaths.
160 for (const auto& object : subtree)
161 {
162 if (!object.second.empty())
163 {
164 const auto& service = object.second.front();
165
166 BMCWEB_LOG_DEBUG("Get intrusion status by service ");
167
168 sdbusplus::asio::getProperty<std::string>(
169 *crow::connections::systemBus, service.first, object.first,
170 "xyz.openbmc_project.Chassis.Intrusion", "Status",
171 [asyncResp](const boost::system::error_code& ec1,
172 const std::string& value) {
173 if (ec1)
174 {
175 // do not add err msg in redfish response, because this
176 // is not
177 // mandatory property
178 BMCWEB_LOG_ERROR("DBUS response error {}", ec1);
179 return;
180 }
181 asyncResp->res.jsonValue["PhysicalSecurity"]
182 ["IntrusionSensorNumber"] = 1;
183 asyncResp->res
184 .jsonValue["PhysicalSecurity"]["IntrusionSensor"] =
185 value;
186 });
187
188 return;
189 }
190 }
191 }
192
handleChassisCollectionGet(App & app,const crow::Request & req,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)193 inline void handleChassisCollectionGet(
194 App& app, const crow::Request& req,
195 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
196 {
197 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
198 {
199 return;
200 }
201 asyncResp->res.jsonValue["@odata.type"] =
202 "#ChassisCollection.ChassisCollection";
203 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Chassis";
204 asyncResp->res.jsonValue["Name"] = "Chassis Collection";
205
206 constexpr std::array<std::string_view, 2> interfaces{
207 "xyz.openbmc_project.Inventory.Item.Board",
208 "xyz.openbmc_project.Inventory.Item.Chassis"};
209 collection_util::getCollectionMembers(
210 asyncResp, boost::urls::url("/redfish/v1/Chassis"), interfaces,
211 "/xyz/openbmc_project/inventory");
212 }
213
getChassisContainedBy(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & chassisId,const boost::system::error_code & ec,const dbus::utility::MapperGetSubTreePathsResponse & upstreamChassisPaths)214 inline void getChassisContainedBy(
215 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
216 const std::string& chassisId, const boost::system::error_code& ec,
217 const dbus::utility::MapperGetSubTreePathsResponse& upstreamChassisPaths)
218 {
219 if (ec)
220 {
221 if (ec.value() != EBADR)
222 {
223 BMCWEB_LOG_ERROR("DBUS response error {}", ec);
224 messages::internalError(asyncResp->res);
225 }
226 return;
227 }
228 if (upstreamChassisPaths.empty())
229 {
230 return;
231 }
232 if (upstreamChassisPaths.size() > 1)
233 {
234 BMCWEB_LOG_ERROR("{} is contained by multiple chassis", chassisId);
235 messages::internalError(asyncResp->res);
236 return;
237 }
238
239 sdbusplus::message::object_path upstreamChassisPath(
240 upstreamChassisPaths[0]);
241 std::string upstreamChassis = upstreamChassisPath.filename();
242 if (upstreamChassis.empty())
243 {
244 BMCWEB_LOG_WARNING("Malformed upstream Chassis path {} on {}",
245 upstreamChassisPath.str, chassisId);
246 return;
247 }
248
249 asyncResp->res.jsonValue["Links"]["ContainedBy"]["@odata.id"] =
250 boost::urls::format("/redfish/v1/Chassis/{}", upstreamChassis);
251 }
252
getChassisContains(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & chassisId,const boost::system::error_code & ec,const dbus::utility::MapperGetSubTreePathsResponse & downstreamChassisPaths)253 inline void getChassisContains(
254 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
255 const std::string& chassisId, const boost::system::error_code& ec,
256 const dbus::utility::MapperGetSubTreePathsResponse& downstreamChassisPaths)
257 {
258 if (ec)
259 {
260 if (ec.value() != EBADR)
261 {
262 BMCWEB_LOG_ERROR("DBUS response error {}", ec);
263 messages::internalError(asyncResp->res);
264 }
265 return;
266 }
267 if (downstreamChassisPaths.empty())
268 {
269 return;
270 }
271 nlohmann::json& jValue = asyncResp->res.jsonValue["Links"]["Contains"];
272 if (!jValue.is_array())
273 {
274 // Create the array if it was empty
275 jValue = nlohmann::json::array();
276 }
277 for (const auto& p : downstreamChassisPaths)
278 {
279 sdbusplus::message::object_path downstreamChassisPath(p);
280 std::string downstreamChassis = downstreamChassisPath.filename();
281 if (downstreamChassis.empty())
282 {
283 BMCWEB_LOG_WARNING("Malformed downstream Chassis path {} on {}",
284 downstreamChassisPath.str, chassisId);
285 continue;
286 }
287 nlohmann::json link;
288 link["@odata.id"] =
289 boost::urls::format("/redfish/v1/Chassis/{}", downstreamChassis);
290 jValue.push_back(std::move(link));
291 }
292 asyncResp->res.jsonValue["Links"]["Contains@odata.count"] = jValue.size();
293 }
294
getChassisConnectivity(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & chassisId,const std::string & chassisPath)295 inline void getChassisConnectivity(
296 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
297 const std::string& chassisId, const std::string& chassisPath)
298 {
299 BMCWEB_LOG_DEBUG("Get chassis connectivity");
300
301 constexpr std::array<std::string_view, 2> interfaces{
302 "xyz.openbmc_project.Inventory.Item.Board",
303 "xyz.openbmc_project.Inventory.Item.Chassis"};
304
305 dbus::utility::getAssociatedSubTreePaths(
306 chassisPath + "/contained_by",
307 sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), 0,
308 interfaces,
309 std::bind_front(getChassisContainedBy, asyncResp, chassisId));
310
311 dbus::utility::getAssociatedSubTreePaths(
312 chassisPath + "/containing",
313 sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), 0,
314 interfaces, std::bind_front(getChassisContains, asyncResp, chassisId));
315 }
316
317 /**
318 * ChassisCollection derived class for delivering Chassis Collection Schema
319 * Functions triggers appropriate requests on DBus
320 */
requestRoutesChassisCollection(App & app)321 inline void requestRoutesChassisCollection(App& app)
322 {
323 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/")
324 .privileges(redfish::privileges::getChassisCollection)
325 .methods(boost::beast::http::verb::get)(
326 std::bind_front(handleChassisCollectionGet, std::ref(app)));
327 }
328
getChassisLocationCode(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & connectionName,const std::string & path)329 inline void getChassisLocationCode(
330 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
331 const std::string& connectionName, const std::string& path)
332 {
333 sdbusplus::asio::getProperty<std::string>(
334 *crow::connections::systemBus, connectionName, path,
335 "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode",
336 [asyncResp](const boost::system::error_code& ec,
337 const std::string& property) {
338 if (ec)
339 {
340 BMCWEB_LOG_ERROR("DBUS response error for Location");
341 messages::internalError(asyncResp->res);
342 return;
343 }
344
345 asyncResp->res
346 .jsonValue["Location"]["PartLocation"]["ServiceLabel"] =
347 property;
348 });
349 }
350
getChassisUUID(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & connectionName,const std::string & path)351 inline void getChassisUUID(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
352 const std::string& connectionName,
353 const std::string& path)
354 {
355 sdbusplus::asio::getProperty<std::string>(
356 *crow::connections::systemBus, connectionName, path,
357 "xyz.openbmc_project.Common.UUID", "UUID",
358 [asyncResp](const boost::system::error_code& ec,
359 const std::string& chassisUUID) {
360 if (ec)
361 {
362 BMCWEB_LOG_ERROR("DBUS response error for UUID");
363 messages::internalError(asyncResp->res);
364 return;
365 }
366 asyncResp->res.jsonValue["UUID"] = chassisUUID;
367 });
368 }
369
handleDecoratorAssetProperties(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & chassisId,const std::string & path,const dbus::utility::DBusPropertiesMap & propertiesList)370 inline void handleDecoratorAssetProperties(
371 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
372 const std::string& chassisId, const std::string& path,
373 const dbus::utility::DBusPropertiesMap& propertiesList)
374 {
375 const std::string* partNumber = nullptr;
376 const std::string* serialNumber = nullptr;
377 const std::string* manufacturer = nullptr;
378 const std::string* model = nullptr;
379 const std::string* sparePartNumber = nullptr;
380
381 const bool success = sdbusplus::unpackPropertiesNoThrow(
382 dbus_utils::UnpackErrorPrinter(), propertiesList, "PartNumber",
383 partNumber, "SerialNumber", serialNumber, "Manufacturer", manufacturer,
384 "Model", model, "SparePartNumber", sparePartNumber);
385
386 if (!success)
387 {
388 messages::internalError(asyncResp->res);
389 return;
390 }
391
392 if (partNumber != nullptr)
393 {
394 asyncResp->res.jsonValue["PartNumber"] = *partNumber;
395 }
396
397 if (serialNumber != nullptr)
398 {
399 asyncResp->res.jsonValue["SerialNumber"] = *serialNumber;
400 }
401
402 if (manufacturer != nullptr)
403 {
404 asyncResp->res.jsonValue["Manufacturer"] = *manufacturer;
405 }
406
407 if (model != nullptr)
408 {
409 asyncResp->res.jsonValue["Model"] = *model;
410 }
411
412 // SparePartNumber is optional on D-Bus
413 // so skip if it is empty
414 if (sparePartNumber != nullptr && !sparePartNumber->empty())
415 {
416 asyncResp->res.jsonValue["SparePartNumber"] = *sparePartNumber;
417 }
418
419 asyncResp->res.jsonValue["Name"] = chassisId;
420 asyncResp->res.jsonValue["Id"] = chassisId;
421
422 if constexpr (BMCWEB_REDFISH_ALLOW_DEPRECATED_POWER_THERMAL)
423 {
424 asyncResp->res.jsonValue["Thermal"]["@odata.id"] =
425 boost::urls::format("/redfish/v1/Chassis/{}/Thermal", chassisId);
426 // Power object
427 asyncResp->res.jsonValue["Power"]["@odata.id"] =
428 boost::urls::format("/redfish/v1/Chassis/{}/Power", chassisId);
429 }
430
431 if constexpr (BMCWEB_REDFISH_NEW_POWERSUBSYSTEM_THERMALSUBSYSTEM)
432 {
433 asyncResp->res.jsonValue["ThermalSubsystem"]["@odata.id"] =
434 boost::urls::format("/redfish/v1/Chassis/{}/ThermalSubsystem",
435 chassisId);
436 asyncResp->res.jsonValue["PowerSubsystem"]["@odata.id"] =
437 boost::urls::format("/redfish/v1/Chassis/{}/PowerSubsystem",
438 chassisId);
439 asyncResp->res.jsonValue["EnvironmentMetrics"]["@odata.id"] =
440 boost::urls::format("/redfish/v1/Chassis/{}/EnvironmentMetrics",
441 chassisId);
442 }
443 // SensorCollection
444 asyncResp->res.jsonValue["Sensors"]["@odata.id"] =
445 boost::urls::format("/redfish/v1/Chassis/{}/Sensors", chassisId);
446 asyncResp->res.jsonValue["Status"]["State"] = resource::State::Enabled;
447
448 nlohmann::json::array_t computerSystems;
449 nlohmann::json::object_t system;
450 system["@odata.id"] =
451 std::format("/redfish/v1/Systems/{}", BMCWEB_REDFISH_SYSTEM_URI_NAME);
452 computerSystems.emplace_back(std::move(system));
453 asyncResp->res.jsonValue["Links"]["ComputerSystems"] =
454 std::move(computerSystems);
455
456 nlohmann::json::array_t managedBy;
457 nlohmann::json::object_t manager;
458 manager["@odata.id"] = boost::urls::format("/redfish/v1/Managers/{}",
459 BMCWEB_REDFISH_MANAGER_URI_NAME);
460 managedBy.emplace_back(std::move(manager));
461 asyncResp->res.jsonValue["Links"]["ManagedBy"] = std::move(managedBy);
462 getChassisState(asyncResp);
463 getStorageLink(asyncResp, path);
464 }
465
handleChassisGetSubTree(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & chassisId,const boost::system::error_code & ec,const dbus::utility::MapperGetSubTreeResponse & subtree)466 inline void handleChassisGetSubTree(
467 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
468 const std::string& chassisId, const boost::system::error_code& ec,
469 const dbus::utility::MapperGetSubTreeResponse& subtree)
470 {
471 if (ec)
472 {
473 BMCWEB_LOG_ERROR("DBUS response error {}", ec);
474 messages::internalError(asyncResp->res);
475 return;
476 }
477 // Iterate over all retrieved ObjectPaths.
478 for (const std::pair<
479 std::string,
480 std::vector<std::pair<std::string, std::vector<std::string>>>>&
481 object : subtree)
482 {
483 const std::string& path = object.first;
484 const std::vector<std::pair<std::string, std::vector<std::string>>>&
485 connectionNames = object.second;
486
487 sdbusplus::message::object_path objPath(path);
488 if (objPath.filename() != chassisId)
489 {
490 continue;
491 }
492
493 getChassisConnectivity(asyncResp, chassisId, path);
494
495 if (connectionNames.empty())
496 {
497 BMCWEB_LOG_ERROR("Got 0 Connection names");
498 continue;
499 }
500
501 asyncResp->res.jsonValue["@odata.type"] = "#Chassis.v1_22_0.Chassis";
502 asyncResp->res.jsonValue["@odata.id"] =
503 boost::urls::format("/redfish/v1/Chassis/{}", chassisId);
504 asyncResp->res.jsonValue["Name"] = "Chassis Collection";
505 asyncResp->res.jsonValue["ChassisType"] =
506 chassis::ChassisType::RackMount;
507 asyncResp->res.jsonValue["Actions"]["#Chassis.Reset"]["target"] =
508 boost::urls::format("/redfish/v1/Chassis/{}/Actions/Chassis.Reset",
509 chassisId);
510 asyncResp->res
511 .jsonValue["Actions"]["#Chassis.Reset"]["@Redfish.ActionInfo"] =
512 boost::urls::format("/redfish/v1/Chassis/{}/ResetActionInfo",
513 chassisId);
514 dbus::utility::getAssociationEndPoints(
515 path + "/drive",
516 [asyncResp, chassisId](const boost::system::error_code& ec3,
517 const dbus::utility::MapperEndPoints& resp) {
518 if (ec3 || resp.empty())
519 {
520 return; // no drives = no failures
521 }
522
523 nlohmann::json reference;
524 reference["@odata.id"] = boost::urls::format(
525 "/redfish/v1/Chassis/{}/Drives", chassisId);
526 asyncResp->res.jsonValue["Drives"] = std::move(reference);
527 });
528
529 const std::string& connectionName = connectionNames[0].first;
530
531 const std::vector<std::string>& interfaces2 = connectionNames[0].second;
532 const std::array<const char*, 3> hasIndicatorLed = {
533 "xyz.openbmc_project.Inventory.Item.Chassis",
534 "xyz.openbmc_project.Inventory.Item.Panel",
535 "xyz.openbmc_project.Inventory.Item.Board.Motherboard"};
536
537 const std::string assetTagInterface =
538 "xyz.openbmc_project.Inventory.Decorator.AssetTag";
539 const std::string replaceableInterface =
540 "xyz.openbmc_project.Inventory.Decorator.Replaceable";
541 const std::string revisionInterface =
542 "xyz.openbmc_project.Inventory.Decorator.Revision";
543 for (const auto& interface : interfaces2)
544 {
545 if (interface == assetTagInterface)
546 {
547 sdbusplus::asio::getProperty<std::string>(
548 *crow::connections::systemBus, connectionName, path,
549 assetTagInterface, "AssetTag",
550 [asyncResp, chassisId](const boost::system::error_code& ec2,
551 const std::string& property) {
552 if (ec2)
553 {
554 BMCWEB_LOG_ERROR(
555 "DBus response error for AssetTag: {}", ec2);
556 messages::internalError(asyncResp->res);
557 return;
558 }
559 asyncResp->res.jsonValue["AssetTag"] = property;
560 });
561 }
562 else if (interface == replaceableInterface)
563 {
564 sdbusplus::asio::getProperty<bool>(
565 *crow::connections::systemBus, connectionName, path,
566 replaceableInterface, "HotPluggable",
567 [asyncResp, chassisId](const boost::system::error_code& ec2,
568 const bool property) {
569 if (ec2)
570 {
571 BMCWEB_LOG_ERROR(
572 "DBus response error for HotPluggable: {}",
573 ec2);
574 messages::internalError(asyncResp->res);
575 return;
576 }
577 asyncResp->res.jsonValue["HotPluggable"] = property;
578 });
579 }
580 else if (interface == revisionInterface)
581 {
582 sdbusplus::asio::getProperty<std::string>(
583 *crow::connections::systemBus, connectionName, path,
584 revisionInterface, "Version",
585 [asyncResp, chassisId](const boost::system::error_code& ec2,
586 const std::string& property) {
587 if (ec2)
588 {
589 BMCWEB_LOG_ERROR(
590 "DBus response error for Version: {}", ec2);
591 messages::internalError(asyncResp->res);
592 return;
593 }
594 asyncResp->res.jsonValue["Version"] = property;
595 });
596 }
597 }
598
599 for (const char* interface : hasIndicatorLed)
600 {
601 if (std::ranges::find(interfaces2, interface) != interfaces2.end())
602 {
603 getIndicatorLedState(asyncResp);
604 getSystemLocationIndicatorActive(asyncResp);
605 break;
606 }
607 }
608
609 sdbusplus::asio::getAllProperties(
610 *crow::connections::systemBus, connectionName, path,
611 "xyz.openbmc_project.Inventory.Decorator.Asset",
612 [asyncResp, chassisId,
613 path](const boost::system::error_code&,
614 const dbus::utility::DBusPropertiesMap& propertiesList) {
615 handleDecoratorAssetProperties(asyncResp, chassisId, path,
616 propertiesList);
617 });
618
619 for (const auto& interface : interfaces2)
620 {
621 if (interface == "xyz.openbmc_project.Common.UUID")
622 {
623 getChassisUUID(asyncResp, connectionName, path);
624 }
625 else if (interface ==
626 "xyz.openbmc_project.Inventory.Decorator.LocationCode")
627 {
628 getChassisLocationCode(asyncResp, connectionName, path);
629 }
630 }
631
632 return;
633 }
634
635 // Couldn't find an object with that name. return an error
636 messages::resourceNotFound(asyncResp->res, "Chassis", chassisId);
637 }
638
639 inline void
handleChassisGet(App & app,const crow::Request & req,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & chassisId)640 handleChassisGet(App& app, const crow::Request& req,
641 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
642 const std::string& chassisId)
643 {
644 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
645 {
646 return;
647 }
648 constexpr std::array<std::string_view, 2> interfaces = {
649 "xyz.openbmc_project.Inventory.Item.Board",
650 "xyz.openbmc_project.Inventory.Item.Chassis"};
651
652 dbus::utility::getSubTree(
653 "/xyz/openbmc_project/inventory", 0, interfaces,
654 std::bind_front(handleChassisGetSubTree, asyncResp, chassisId));
655
656 constexpr std::array<std::string_view, 1> interfaces2 = {
657 "xyz.openbmc_project.Chassis.Intrusion"};
658
659 dbus::utility::getSubTree(
660 "/xyz/openbmc_project", 0, interfaces2,
661 std::bind_front(handlePhysicalSecurityGetSubTree, asyncResp));
662 }
663
664 inline void
handleChassisPatch(App & app,const crow::Request & req,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & param)665 handleChassisPatch(App& app, const crow::Request& req,
666 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
667 const std::string& param)
668 {
669 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
670 {
671 return;
672 }
673 std::optional<bool> locationIndicatorActive;
674 std::optional<std::string> indicatorLed;
675
676 if (param.empty())
677 {
678 return;
679 }
680
681 if (!json_util::readJsonPatch(
682 req, asyncResp->res, "LocationIndicatorActive",
683 locationIndicatorActive, "IndicatorLED", indicatorLed))
684 {
685 return;
686 }
687
688 // TODO (Gunnar): Remove IndicatorLED after enough time has passed
689 if (!locationIndicatorActive && !indicatorLed)
690 {
691 return; // delete this when we support more patch properties
692 }
693 if (indicatorLed)
694 {
695 asyncResp->res.addHeader(
696 boost::beast::http::field::warning,
697 "299 - \"IndicatorLED is deprecated. Use LocationIndicatorActive instead.\"");
698 }
699
700 constexpr std::array<std::string_view, 2> interfaces = {
701 "xyz.openbmc_project.Inventory.Item.Board",
702 "xyz.openbmc_project.Inventory.Item.Chassis"};
703
704 const std::string& chassisId = param;
705
706 dbus::utility::getSubTree(
707 "/xyz/openbmc_project/inventory", 0, interfaces,
708 [asyncResp, chassisId, locationIndicatorActive,
709 indicatorLed](const boost::system::error_code& ec,
710 const dbus::utility::MapperGetSubTreeResponse& subtree) {
711 if (ec)
712 {
713 BMCWEB_LOG_ERROR("DBUS response error {}", ec);
714 messages::internalError(asyncResp->res);
715 return;
716 }
717
718 // Iterate over all retrieved ObjectPaths.
719 for (const std::pair<std::string,
720 std::vector<std::pair<
721 std::string, std::vector<std::string>>>>&
722 object : subtree)
723 {
724 const std::string& path = object.first;
725 const std::vector<
726 std::pair<std::string, std::vector<std::string>>>&
727 connectionNames = object.second;
728
729 sdbusplus::message::object_path objPath(path);
730 if (objPath.filename() != chassisId)
731 {
732 continue;
733 }
734
735 if (connectionNames.empty())
736 {
737 BMCWEB_LOG_ERROR("Got 0 Connection names");
738 continue;
739 }
740
741 const std::vector<std::string>& interfaces3 =
742 connectionNames[0].second;
743
744 const std::array<const char*, 3> hasIndicatorLed = {
745 "xyz.openbmc_project.Inventory.Item.Chassis",
746 "xyz.openbmc_project.Inventory.Item.Panel",
747 "xyz.openbmc_project.Inventory.Item.Board.Motherboard"};
748 bool indicatorChassis = false;
749 for (const char* interface : hasIndicatorLed)
750 {
751 if (std::ranges::find(interfaces3, interface) !=
752 interfaces3.end())
753 {
754 indicatorChassis = true;
755 break;
756 }
757 }
758 if (locationIndicatorActive)
759 {
760 if (indicatorChassis)
761 {
762 setSystemLocationIndicatorActive(
763 asyncResp, *locationIndicatorActive);
764 }
765 else
766 {
767 messages::propertyUnknown(asyncResp->res,
768 "LocationIndicatorActive");
769 }
770 }
771 if (indicatorLed)
772 {
773 if (indicatorChassis)
774 {
775 setIndicatorLedState(asyncResp, *indicatorLed);
776 }
777 else
778 {
779 messages::propertyUnknown(asyncResp->res,
780 "IndicatorLED");
781 }
782 }
783 return;
784 }
785
786 messages::resourceNotFound(asyncResp->res, "Chassis", chassisId);
787 });
788 }
789
790 /**
791 * Chassis override class for delivering Chassis Schema
792 * Functions triggers appropriate requests on DBus
793 */
requestRoutesChassis(App & app)794 inline void requestRoutesChassis(App& app)
795 {
796 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/")
797 .privileges(redfish::privileges::getChassis)
798 .methods(boost::beast::http::verb::get)(
799 std::bind_front(handleChassisGet, std::ref(app)));
800
801 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/")
802 .privileges(redfish::privileges::patchChassis)
803 .methods(boost::beast::http::verb::patch)(
804 std::bind_front(handleChassisPatch, std::ref(app)));
805 }
806
807 inline void
doChassisPowerCycle(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)808 doChassisPowerCycle(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
809 {
810 constexpr std::array<std::string_view, 1> interfaces = {
811 "xyz.openbmc_project.State.Chassis"};
812
813 // Use mapper to get subtree paths.
814 dbus::utility::getSubTreePaths(
815 "/", 0, interfaces,
816 [asyncResp](
817 const boost::system::error_code& ec,
818 const dbus::utility::MapperGetSubTreePathsResponse& chassisList) {
819 if (ec)
820 {
821 BMCWEB_LOG_ERROR("[mapper] Bad D-Bus request error: {}", ec);
822 messages::internalError(asyncResp->res);
823 return;
824 }
825
826 const char* processName = "xyz.openbmc_project.State.Chassis";
827 const char* interfaceName = "xyz.openbmc_project.State.Chassis";
828 const char* destProperty = "RequestedPowerTransition";
829 const std::string propertyValue =
830 "xyz.openbmc_project.State.Chassis.Transition.PowerCycle";
831 std::string objectPath =
832 "/xyz/openbmc_project/state/chassis_system0";
833
834 /* Look for system reset chassis path */
835 if ((std::ranges::find(chassisList, objectPath)) ==
836 chassisList.end())
837 {
838 /* We prefer to reset the full chassis_system, but if it doesn't
839 * exist on some platforms, fall back to a host-only power reset
840 */
841 objectPath = "/xyz/openbmc_project/state/chassis0";
842 }
843
844 setDbusProperty(asyncResp, "ResetType", processName, objectPath,
845 interfaceName, destProperty, propertyValue);
846 });
847 }
848
handleChassisResetActionInfoPost(App & app,const crow::Request & req,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string &)849 inline void handleChassisResetActionInfoPost(
850 App& app, const crow::Request& req,
851 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
852 const std::string& /*chassisId*/)
853 {
854 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
855 {
856 return;
857 }
858 BMCWEB_LOG_DEBUG("Post Chassis Reset.");
859
860 std::string resetType;
861
862 if (!json_util::readJsonAction(req, asyncResp->res, "ResetType", resetType))
863 {
864 return;
865 }
866
867 if (resetType != "PowerCycle")
868 {
869 BMCWEB_LOG_DEBUG("Invalid property value for ResetType: {}", resetType);
870 messages::actionParameterNotSupported(asyncResp->res, resetType,
871 "ResetType");
872
873 return;
874 }
875 doChassisPowerCycle(asyncResp);
876 }
877
878 /**
879 * ChassisResetAction class supports the POST method for the Reset
880 * action.
881 * Function handles POST method request.
882 * Analyzes POST body before sending Reset request data to D-Bus.
883 */
884
requestRoutesChassisResetAction(App & app)885 inline void requestRoutesChassisResetAction(App& app)
886 {
887 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Actions/Chassis.Reset/")
888 .privileges(redfish::privileges::postChassis)
889 .methods(boost::beast::http::verb::post)(
890 std::bind_front(handleChassisResetActionInfoPost, std::ref(app)));
891 }
892
handleChassisResetActionInfoGet(App & app,const crow::Request & req,const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & chassisId)893 inline void handleChassisResetActionInfoGet(
894 App& app, const crow::Request& req,
895 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
896 const std::string& chassisId)
897 {
898 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
899 {
900 return;
901 }
902 asyncResp->res.jsonValue["@odata.type"] = "#ActionInfo.v1_1_2.ActionInfo";
903 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
904 "/redfish/v1/Chassis/{}/ResetActionInfo", chassisId);
905 asyncResp->res.jsonValue["Name"] = "Reset Action Info";
906
907 asyncResp->res.jsonValue["Id"] = "ResetActionInfo";
908 nlohmann::json::array_t parameters;
909 nlohmann::json::object_t parameter;
910 parameter["Name"] = "ResetType";
911 parameter["Required"] = true;
912 parameter["DataType"] = action_info::ParameterTypes::String;
913 nlohmann::json::array_t allowed;
914 allowed.emplace_back("PowerCycle");
915 parameter["AllowableValues"] = std::move(allowed);
916 parameters.emplace_back(std::move(parameter));
917
918 asyncResp->res.jsonValue["Parameters"] = std::move(parameters);
919 }
920
921 /**
922 * ChassisResetActionInfo derived class for delivering Chassis
923 * ResetType AllowableValues using ResetInfo schema.
924 */
requestRoutesChassisResetActionInfo(App & app)925 inline void requestRoutesChassisResetActionInfo(App& app)
926 {
927 BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ResetActionInfo/")
928 .privileges(redfish::privileges::getActionInfo)
929 .methods(boost::beast::http::verb::get)(
930 std::bind_front(handleChassisResetActionInfoGet, std::ref(app)));
931 }
932
933 } // namespace redfish
934