xref: /openbmc/bmcweb/redfish-core/lib/chassis.hpp (revision 04e438cbad66838724d78ce12f28aff1fb892a63) 
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_10_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                             break;
322                         }
323                     }
324 
325                     crow::connections::systemBus->async_method_call(
326                         [asyncResp, chassisId(std::string(chassisId))](
327                             const boost::system::error_code /*ec2*/,
328                             const std::vector<std::pair<
329                                 std::string, VariantType>>& propertiesList) {
330                             for (const std::pair<std::string, VariantType>&
331                                      property : propertiesList)
332                             {
333                                 // Store DBus properties that are also Redfish
334                                 // properties with same name and a string value
335                                 const std::string& propertyName =
336                                     property.first;
337                                 if ((propertyName == "PartNumber") ||
338                                     (propertyName == "SerialNumber") ||
339                                     (propertyName == "Manufacturer") ||
340                                     (propertyName == "Model"))
341                                 {
342                                     const std::string* value =
343                                         std::get_if<std::string>(
344                                             &property.second);
345                                     if (value != nullptr)
346                                     {
347                                         asyncResp->res.jsonValue[propertyName] =
348                                             *value;
349                                     }
350                                 }
351                             }
352                             asyncResp->res.jsonValue["Name"] = chassisId;
353                             asyncResp->res.jsonValue["Id"] = chassisId;
354                             asyncResp->res.jsonValue["Thermal"] = {
355                                 {"@odata.id", "/redfish/v1/Chassis/" +
356                                                   chassisId + "/Thermal"}};
357                             // Power object
358                             asyncResp->res.jsonValue["Power"] = {
359                                 {"@odata.id", "/redfish/v1/Chassis/" +
360                                                   chassisId + "/Power"}};
361                             // SensorCollection
362                             asyncResp->res.jsonValue["Sensors"] = {
363                                 {"@odata.id", "/redfish/v1/Chassis/" +
364                                                   chassisId + "/Sensors"}};
365                             asyncResp->res.jsonValue["Status"] = {
366                                 {"State", "Enabled"},
367                             };
368 
369                             asyncResp->res
370                                 .jsonValue["Links"]["ComputerSystems"] = {
371                                 {{"@odata.id", "/redfish/v1/Systems/system"}}};
372                             asyncResp->res.jsonValue["Links"]["ManagedBy"] = {
373                                 {{"@odata.id", "/redfish/v1/Managers/bmc"}}};
374                             getChassisState(asyncResp);
375                         },
376                         connectionName, path, "org.freedesktop.DBus.Properties",
377                         "GetAll",
378                         "xyz.openbmc_project.Inventory.Decorator.Asset");
379                     return;
380                 }
381 
382                 // Couldn't find an object with that name.  return an error
383                 messages::resourceNotFound(
384                     asyncResp->res, "#Chassis.v1_10_0.Chassis", chassisId);
385             },
386             "xyz.openbmc_project.ObjectMapper",
387             "/xyz/openbmc_project/object_mapper",
388             "xyz.openbmc_project.ObjectMapper", "GetSubTree",
389             "/xyz/openbmc_project/inventory", 0, interfaces);
390 
391         getPhysicalSecurityData(asyncResp);
392     }
393 
394     void doPatch(crow::Response& res, const crow::Request& req,
395                  const std::vector<std::string>& params) override
396     {
397         std::optional<std::string> indicatorLed;
398         auto asyncResp = std::make_shared<AsyncResp>(res);
399 
400         if (params.size() != 1)
401         {
402             return;
403         }
404 
405         if (!json_util::readJson(req, res, "IndicatorLED", indicatorLed))
406         {
407             return;
408         }
409 
410         if (!indicatorLed)
411         {
412             return; // delete this when we support more patch properties
413         }
414 
415         const std::array<const char*, 2> interfaces = {
416             "xyz.openbmc_project.Inventory.Item.Board",
417             "xyz.openbmc_project.Inventory.Item.Chassis"};
418 
419         const std::string& chassisId = params[0];
420 
421         crow::connections::systemBus->async_method_call(
422             [asyncResp, chassisId, indicatorLed](
423                 const boost::system::error_code ec,
424                 const crow::openbmc_mapper::GetSubTreeType& subtree) {
425                 if (ec)
426                 {
427                     messages::internalError(asyncResp->res);
428                     return;
429                 }
430 
431                 // Iterate over all retrieved ObjectPaths.
432                 for (const std::pair<
433                          std::string,
434                          std::vector<
435                              std::pair<std::string, std::vector<std::string>>>>&
436                          object : subtree)
437                 {
438                     const std::string& path = object.first;
439                     const std::vector<
440                         std::pair<std::string, std::vector<std::string>>>&
441                         connectionNames = object.second;
442 
443                     if (!boost::ends_with(path, chassisId))
444                     {
445                         continue;
446                     }
447 
448                     if (connectionNames.size() < 1)
449                     {
450                         BMCWEB_LOG_ERROR << "Got 0 Connection names";
451                         continue;
452                     }
453 
454                     const std::vector<std::string>& interfaces3 =
455                         connectionNames[0].second;
456 
457                     if (indicatorLed)
458                     {
459                         const std::array<const char*, 2> hasIndicatorLed = {
460                             "xyz.openbmc_project.Inventory.Item.Panel",
461                             "xyz.openbmc_project.Inventory.Item.Board."
462                             "Motherboard"};
463                         bool indicatorChassis = false;
464                         for (const char* interface : hasIndicatorLed)
465                         {
466                             if (std::find(interfaces3.begin(),
467                                           interfaces3.end(),
468                                           interface) != interfaces3.end())
469                             {
470                                 indicatorChassis = true;
471                                 break;
472                             }
473                         }
474                         if (indicatorChassis)
475                         {
476                             setIndicatorLedState(asyncResp,
477                                                  std::move(*indicatorLed));
478                         }
479                         else
480                         {
481                             messages::propertyUnknown(asyncResp->res,
482                                                       "IndicatorLED");
483                         }
484                     }
485                     return;
486                 }
487 
488                 messages::resourceNotFound(
489                     asyncResp->res, "#Chassis.v1_10_0.Chassis", chassisId);
490             },
491             "xyz.openbmc_project.ObjectMapper",
492             "/xyz/openbmc_project/object_mapper",
493             "xyz.openbmc_project.ObjectMapper", "GetSubTree",
494             "/xyz/openbmc_project/inventory", 0, interfaces);
495     }
496 };
497 
498 inline void doChassisPowerCycle(const std::shared_ptr<AsyncResp>& asyncResp)
499 {
500     const char* busName = "xyz.openbmc_project.ObjectMapper";
501     const char* path = "/xyz/openbmc_project/object_mapper";
502     const char* interface = "xyz.openbmc_project.ObjectMapper";
503     const char* method = "GetSubTreePaths";
504 
505     const std::array<const char*, 1> interfaces = {
506         "xyz.openbmc_project.State.Chassis"};
507 
508     // Use mapper to get subtree paths.
509     crow::connections::systemBus->async_method_call(
510         [asyncResp](const boost::system::error_code ec,
511                     const std::vector<std::string>& chassisList) {
512             if (ec)
513             {
514                 BMCWEB_LOG_DEBUG << "[mapper] Bad D-Bus request error: " << ec;
515                 messages::internalError(asyncResp->res);
516                 return;
517             }
518 
519             const char* processName = "xyz.openbmc_project.State.Chassis";
520             const char* interfaceName = "xyz.openbmc_project.State.Chassis";
521             const char* destProperty = "RequestedPowerTransition";
522             const std::string propertyValue =
523                 "xyz.openbmc_project.State.Chassis.Transition.PowerCycle";
524             std::string objectPath =
525                 "/xyz/openbmc_project/state/chassis_system0";
526 
527             /* Look for system reset chassis path */
528             if ((std::find(chassisList.begin(), chassisList.end(),
529                            objectPath)) == chassisList.end())
530             {
531                 /* We prefer to reset the full chassis_system, but if it doesn't
532                  * exist on some platforms, fall back to a host-only power reset
533                  */
534                 objectPath = "/xyz/openbmc_project/state/chassis0";
535             }
536 
537             crow::connections::systemBus->async_method_call(
538                 [asyncResp](const boost::system::error_code ec) {
539                     // Use "Set" method to set the property value.
540                     if (ec)
541                     {
542                         BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: "
543                                          << ec;
544                         messages::internalError(asyncResp->res);
545                         return;
546                     }
547 
548                     messages::success(asyncResp->res);
549                 },
550                 processName, objectPath, "org.freedesktop.DBus.Properties",
551                 "Set", interfaceName, destProperty,
552                 std::variant<std::string>{propertyValue});
553         },
554         busName, path, interface, method, "/", 0, interfaces);
555 }
556 
557 /**
558  * ChassisResetAction class supports the POST method for the Reset
559  * action.
560  */
561 class ChassisResetAction : public Node
562 {
563   public:
564     ChassisResetAction(App& app) :
565         Node(app, "/redfish/v1/Chassis/<str>/Actions/Chassis.Reset/",
566              std::string())
567     {
568         entityPrivileges = {
569             {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
570     }
571 
572   private:
573     /**
574      * Function handles POST method request.
575      * Analyzes POST body before sending Reset request data to D-Bus.
576      */
577     void doPost(crow::Response& res, const crow::Request& req,
578                 const std::vector<std::string>&) override
579     {
580         BMCWEB_LOG_DEBUG << "Post Chassis Reset.";
581 
582         std::string resetType;
583         auto asyncResp = std::make_shared<AsyncResp>(res);
584 
585         if (!json_util::readJson(req, asyncResp->res, "ResetType", resetType))
586         {
587             return;
588         }
589 
590         if (resetType != "PowerCycle")
591         {
592             BMCWEB_LOG_DEBUG << "Invalid property value for ResetType: "
593                              << resetType;
594             messages::actionParameterNotSupported(asyncResp->res, resetType,
595                                                   "ResetType");
596 
597             return;
598         }
599         doChassisPowerCycle(asyncResp);
600     }
601 };
602 
603 /**
604  * ChassisResetActionInfo derived class for delivering Chassis
605  * ResetType AllowableValues using ResetInfo schema.
606  */
607 class ChassisResetActionInfo : public Node
608 {
609   public:
610     /*
611      * Default Constructor
612      */
613     ChassisResetActionInfo(App& app) :
614         Node(app, "/redfish/v1/Chassis/<str>/ResetActionInfo/", std::string())
615     {
616         entityPrivileges = {
617             {boost::beast::http::verb::get, {{"Login"}}},
618             {boost::beast::http::verb::head, {{"Login"}}},
619             {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
620             {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
621             {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
622             {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
623     }
624 
625   private:
626     /**
627      * Functions triggers appropriate requests on DBus
628      */
629     void doGet(crow::Response& res, const crow::Request&,
630                const std::vector<std::string>& params) override
631     {
632         if (params.size() != 1)
633         {
634             messages::internalError(res);
635             res.end();
636             return;
637         }
638         const std::string& chassisId = params[0];
639 
640         res.jsonValue = {{"@odata.type", "#ActionInfo.v1_1_2.ActionInfo"},
641                          {"@odata.id", "/redfish/v1/Chassis/" + chassisId +
642                                            "/ResetActionInfo"},
643                          {"Name", "Reset Action Info"},
644                          {"Id", "ResetActionInfo"},
645                          {"Parameters",
646                           {{{"Name", "ResetType"},
647                             {"Required", true},
648                             {"DataType", "String"},
649                             {"AllowableValues", {"PowerCycle"}}}}}};
650         res.end();
651     }
652 };
653 
654 } // namespace redfish
655