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