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