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