blob: 201f2f41a3b61d52f07be3632a73aa55c3dfc782 [file] [log] [blame]
Borawski.Lukasz9c3106852018-02-09 15:24:22 +01001/*
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
James Feistb49ac872019-05-21 15:12:01 -070018#include "health.hpp"
Jennifer Leec5d03ff2019-03-08 15:42:58 -080019#include "redfish_util.hpp"
Borawski.Lukasz9c3106852018-02-09 15:24:22 +010020
John Edward Broadbent7e860f12021-04-08 15:57:16 -070021#include <app.hpp>
James Feist5b4aa862018-08-16 14:07:01 -070022#include <boost/algorithm/string/replace.hpp>
Santosh Puranikaf5d60582019-03-20 18:16:36 +053023#include <boost/date_time.hpp>
James Feist5b4aa862018-08-16 14:07:01 -070024#include <dbus_utility.hpp>
Ed Tanoused398212021-06-09 17:05:54 -070025#include <registries/privilege_registry.hpp>
Andrew Geisslere90c5052019-06-28 13:52:27 -050026#include <utils/fw_utils.hpp>
Bernard Wong7bffdb72019-03-20 16:17:21 +080027#include <utils/systemd_utils.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050028
Gunnar Mills4bfefa72020-07-30 13:54:29 -050029#include <cstdint>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050030#include <memory>
31#include <sstream>
Ed Tanousabf2add2019-01-22 16:40:12 -080032#include <variant>
James Feist5b4aa862018-08-16 14:07:01 -070033
Ed Tanous1abe55e2018-09-05 08:30:59 -070034namespace redfish
35{
Jennifer Leeed5befb2018-08-10 11:29:45 -070036
37/**
Gunnar Mills2a5c4402020-05-19 09:07:24 -050038 * Function reboots the BMC.
39 *
40 * @param[in] asyncResp - Shared pointer for completing asynchronous calls
Jennifer Leeed5befb2018-08-10 11:29:45 -070041 */
zhanghch058d1b46d2021-04-01 11:18:24 +080042inline void
43 doBMCGracefulRestart(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Gunnar Mills2a5c4402020-05-19 09:07:24 -050044{
45 const char* processName = "xyz.openbmc_project.State.BMC";
46 const char* objectPath = "/xyz/openbmc_project/state/bmc0";
47 const char* interfaceName = "xyz.openbmc_project.State.BMC";
48 const std::string& propertyValue =
49 "xyz.openbmc_project.State.BMC.Transition.Reboot";
50 const char* destProperty = "RequestedBMCTransition";
51
52 // Create the D-Bus variant for D-Bus call.
Ed Tanous168e20c2021-12-13 14:39:53 -080053 dbus::utility::DbusVariantType dbusPropertyValue(propertyValue);
Gunnar Mills2a5c4402020-05-19 09:07:24 -050054
55 crow::connections::systemBus->async_method_call(
56 [asyncResp](const boost::system::error_code ec) {
57 // Use "Set" method to set the property value.
58 if (ec)
59 {
60 BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec;
61 messages::internalError(asyncResp->res);
62 return;
63 }
64
65 messages::success(asyncResp->res);
66 },
67 processName, objectPath, "org.freedesktop.DBus.Properties", "Set",
68 interfaceName, destProperty, dbusPropertyValue);
69}
70
zhanghch058d1b46d2021-04-01 11:18:24 +080071inline void
72 doBMCForceRestart(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Jayaprakash Mutyalaf92af382020-06-16 23:29:41 +000073{
74 const char* processName = "xyz.openbmc_project.State.BMC";
75 const char* objectPath = "/xyz/openbmc_project/state/bmc0";
76 const char* interfaceName = "xyz.openbmc_project.State.BMC";
77 const std::string& propertyValue =
78 "xyz.openbmc_project.State.BMC.Transition.HardReboot";
79 const char* destProperty = "RequestedBMCTransition";
80
81 // Create the D-Bus variant for D-Bus call.
Ed Tanous168e20c2021-12-13 14:39:53 -080082 dbus::utility::DbusVariantType dbusPropertyValue(propertyValue);
Jayaprakash Mutyalaf92af382020-06-16 23:29:41 +000083
84 crow::connections::systemBus->async_method_call(
85 [asyncResp](const boost::system::error_code ec) {
86 // Use "Set" method to set the property value.
87 if (ec)
88 {
89 BMCWEB_LOG_DEBUG << "[Set] Bad D-Bus request error: " << ec;
90 messages::internalError(asyncResp->res);
91 return;
92 }
93
94 messages::success(asyncResp->res);
95 },
96 processName, objectPath, "org.freedesktop.DBus.Properties", "Set",
97 interfaceName, destProperty, dbusPropertyValue);
98}
99
Gunnar Mills2a5c4402020-05-19 09:07:24 -0500100/**
101 * ManagerResetAction class supports the POST method for the Reset (reboot)
102 * action.
103 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700104inline void requestRoutesManagerResetAction(App& app)
Jennifer Leeed5befb2018-08-10 11:29:45 -0700105{
Jennifer Leeed5befb2018-08-10 11:29:45 -0700106 /**
Jennifer Leeed5befb2018-08-10 11:29:45 -0700107 * Function handles POST method request.
Gunnar Mills2a5c4402020-05-19 09:07:24 -0500108 * Analyzes POST body before sending Reset (Reboot) request data to D-Bus.
Jayaprakash Mutyalaf92af382020-06-16 23:29:41 +0000109 * OpenBMC supports ResetType "GracefulRestart" and "ForceRestart".
Jennifer Leeed5befb2018-08-10 11:29:45 -0700110 */
Jennifer Leeed5befb2018-08-10 11:29:45 -0700111
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700112 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/Actions/Manager.Reset/")
Ed Tanoused398212021-06-09 17:05:54 -0700113 .privileges(redfish::privileges::postManager)
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700114 .methods(boost::beast::http::verb::post)(
115 [](const crow::Request& req,
116 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
117 BMCWEB_LOG_DEBUG << "Post Manager Reset.";
Gunnar Mills2a5c4402020-05-19 09:07:24 -0500118
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700119 std::string resetType;
Jennifer Leeed5befb2018-08-10 11:29:45 -0700120
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700121 if (!json_util::readJson(req, asyncResp->res, "ResetType",
122 resetType))
123 {
124 return;
125 }
Gunnar Mills2a5c4402020-05-19 09:07:24 -0500126
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700127 if (resetType == "GracefulRestart")
128 {
129 BMCWEB_LOG_DEBUG << "Proceeding with " << resetType;
130 doBMCGracefulRestart(asyncResp);
131 return;
132 }
133 if (resetType == "ForceRestart")
134 {
135 BMCWEB_LOG_DEBUG << "Proceeding with " << resetType;
136 doBMCForceRestart(asyncResp);
137 return;
138 }
139 BMCWEB_LOG_DEBUG << "Invalid property value for ResetType: "
140 << resetType;
141 messages::actionParameterNotSupported(asyncResp->res, resetType,
142 "ResetType");
143
144 return;
145 });
146}
Jennifer Leeed5befb2018-08-10 11:29:45 -0700147
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500148/**
149 * ManagerResetToDefaultsAction class supports POST method for factory reset
150 * action.
151 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700152inline void requestRoutesManagerResetToDefaultsAction(App& app)
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500153{
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500154
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500155 /**
156 * Function handles ResetToDefaults POST method request.
157 *
158 * Analyzes POST body message and factory resets BMC by calling
159 * BMC code updater factory reset followed by a BMC reboot.
160 *
161 * BMC code updater factory reset wipes the whole BMC read-write
162 * filesystem which includes things like the network settings.
163 *
164 * OpenBMC only supports ResetToDefaultsType "ResetAll".
165 */
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500166
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700167 BMCWEB_ROUTE(app,
168 "/redfish/v1/Managers/bmc/Actions/Manager.ResetToDefaults/")
Ed Tanoused398212021-06-09 17:05:54 -0700169 .privileges(redfish::privileges::postManager)
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700170 .methods(boost::beast::http::verb::post)(
171 [](const crow::Request& req,
172 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
173 BMCWEB_LOG_DEBUG << "Post ResetToDefaults.";
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500174
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700175 std::string resetType;
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500176
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700177 if (!json_util::readJson(req, asyncResp->res,
178 "ResetToDefaultsType", resetType))
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500179 {
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700180 BMCWEB_LOG_DEBUG << "Missing property ResetToDefaultsType.";
181
182 messages::actionParameterMissing(asyncResp->res,
183 "ResetToDefaults",
184 "ResetToDefaultsType");
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500185 return;
186 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700187
188 if (resetType != "ResetAll")
189 {
George Liu0fda0f12021-11-16 10:06:17 +0800190 BMCWEB_LOG_DEBUG
191 << "Invalid property value for ResetToDefaultsType: "
192 << resetType;
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700193 messages::actionParameterNotSupported(
194 asyncResp->res, resetType, "ResetToDefaultsType");
195 return;
196 }
197
198 crow::connections::systemBus->async_method_call(
199 [asyncResp](const boost::system::error_code ec) {
200 if (ec)
201 {
202 BMCWEB_LOG_DEBUG << "Failed to ResetToDefaults: "
203 << ec;
204 messages::internalError(asyncResp->res);
205 return;
206 }
207 // Factory Reset doesn't actually happen until a reboot
208 // Can't erase what the BMC is running on
209 doBMCGracefulRestart(asyncResp);
210 },
211 "xyz.openbmc_project.Software.BMC.Updater",
212 "/xyz/openbmc_project/software",
213 "xyz.openbmc_project.Common.FactoryReset", "Reset");
214 });
215}
Gunnar Mills3e40fc72020-05-19 19:18:17 -0500216
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +0530217/**
218 * ManagerResetActionInfo derived class for delivering Manager
219 * ResetType AllowableValues using ResetInfo schema.
220 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700221inline void requestRoutesManagerResetActionInfo(App& app)
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +0530222{
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +0530223 /**
224 * Functions triggers appropriate requests on DBus
225 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700226
227 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/ResetActionInfo/")
Ed Tanoused398212021-06-09 17:05:54 -0700228 .privileges(redfish::privileges::getActionInfo)
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700229 .methods(boost::beast::http::verb::get)(
230 [](const crow::Request&,
231 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
232 asyncResp->res.jsonValue = {
233 {"@odata.type", "#ActionInfo.v1_1_2.ActionInfo"},
234 {"@odata.id", "/redfish/v1/Managers/bmc/ResetActionInfo"},
235 {"Name", "Reset Action Info"},
236 {"Id", "ResetActionInfo"},
237 {"Parameters",
238 {{{"Name", "ResetType"},
239 {"Required", true},
240 {"DataType", "String"},
241 {"AllowableValues",
242 {"GracefulRestart", "ForceRestart"}}}}}};
243 });
244}
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +0530245
James Feist5b4aa862018-08-16 14:07:01 -0700246static constexpr const char* objectManagerIface =
247 "org.freedesktop.DBus.ObjectManager";
248static constexpr const char* pidConfigurationIface =
249 "xyz.openbmc_project.Configuration.Pid";
250static constexpr const char* pidZoneConfigurationIface =
251 "xyz.openbmc_project.Configuration.Pid.Zone";
James Feistb7a08d02018-12-11 14:55:37 -0800252static constexpr const char* stepwiseConfigurationIface =
253 "xyz.openbmc_project.Configuration.Stepwise";
James Feist73df0db2019-03-25 15:29:35 -0700254static constexpr const char* thermalModeIface =
255 "xyz.openbmc_project.Control.ThermalMode";
Borawski.Lukasz9c3106852018-02-09 15:24:22 +0100256
zhanghch058d1b46d2021-04-01 11:18:24 +0800257inline void
258 asyncPopulatePid(const std::string& connection, const std::string& path,
259 const std::string& currentProfile,
260 const std::vector<std::string>& supportedProfiles,
261 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
James Feist5b4aa862018-08-16 14:07:01 -0700262{
263
264 crow::connections::systemBus->async_method_call(
James Feist73df0db2019-03-25 15:29:35 -0700265 [asyncResp, currentProfile, supportedProfiles](
266 const boost::system::error_code ec,
267 const dbus::utility::ManagedObjectType& managedObj) {
James Feist5b4aa862018-08-16 14:07:01 -0700268 if (ec)
269 {
270 BMCWEB_LOG_ERROR << ec;
James Feist5b4aa862018-08-16 14:07:01 -0700271 asyncResp->res.jsonValue.clear();
Jason M. Billsf12894f2018-10-09 12:45:45 -0700272 messages::internalError(asyncResp->res);
James Feist5b4aa862018-08-16 14:07:01 -0700273 return;
274 }
275 nlohmann::json& configRoot =
276 asyncResp->res.jsonValue["Oem"]["OpenBmc"]["Fan"];
277 nlohmann::json& fans = configRoot["FanControllers"];
278 fans["@odata.type"] = "#OemManager.FanControllers";
George Liu0fda0f12021-11-16 10:06:17 +0800279 fans["@odata.id"] =
280 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanControllers";
James Feist5b4aa862018-08-16 14:07:01 -0700281
282 nlohmann::json& pids = configRoot["PidControllers"];
283 pids["@odata.type"] = "#OemManager.PidControllers";
James Feist5b4aa862018-08-16 14:07:01 -0700284 pids["@odata.id"] =
285 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/PidControllers";
286
James Feistb7a08d02018-12-11 14:55:37 -0800287 nlohmann::json& stepwise = configRoot["StepwiseControllers"];
288 stepwise["@odata.type"] = "#OemManager.StepwiseControllers";
James Feistb7a08d02018-12-11 14:55:37 -0800289 stepwise["@odata.id"] =
290 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/StepwiseControllers";
291
James Feist5b4aa862018-08-16 14:07:01 -0700292 nlohmann::json& zones = configRoot["FanZones"];
293 zones["@odata.id"] =
294 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones";
295 zones["@odata.type"] = "#OemManager.FanZones";
James Feist5b4aa862018-08-16 14:07:01 -0700296 configRoot["@odata.id"] =
297 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan";
298 configRoot["@odata.type"] = "#OemManager.Fan";
James Feist73df0db2019-03-25 15:29:35 -0700299 configRoot["Profile@Redfish.AllowableValues"] = supportedProfiles;
300
301 if (!currentProfile.empty())
302 {
303 configRoot["Profile"] = currentProfile;
304 }
305 BMCWEB_LOG_ERROR << "profile = " << currentProfile << " !";
James Feist5b4aa862018-08-16 14:07:01 -0700306
James Feist5b4aa862018-08-16 14:07:01 -0700307 for (const auto& pathPair : managedObj)
308 {
309 for (const auto& intfPair : pathPair.second)
310 {
311 if (intfPair.first != pidConfigurationIface &&
James Feistb7a08d02018-12-11 14:55:37 -0800312 intfPair.first != pidZoneConfigurationIface &&
313 intfPair.first != stepwiseConfigurationIface)
James Feist5b4aa862018-08-16 14:07:01 -0700314 {
315 continue;
316 }
James Feist73df0db2019-03-25 15:29:35 -0700317
Ed Tanous711ac7a2021-12-20 09:34:41 -0800318 std::string name;
James Feist73df0db2019-03-25 15:29:35 -0700319
Ed Tanous711ac7a2021-12-20 09:34:41 -0800320 for (const std::pair<std::string,
321 dbus::utility::DbusVariantType>&
322 propPair : intfPair.second)
James Feist73df0db2019-03-25 15:29:35 -0700323 {
Ed Tanous711ac7a2021-12-20 09:34:41 -0800324 if (propPair.first == "Name")
James Feist73df0db2019-03-25 15:29:35 -0700325 {
Ed Tanous711ac7a2021-12-20 09:34:41 -0800326 const std::string* namePtr =
327 std::get_if<std::string>(&propPair.second);
328 if (namePtr == nullptr)
329 {
330 BMCWEB_LOG_ERROR << "Pid Name Field illegal";
331 messages::internalError(asyncResp->res);
332 return;
333 }
334 std::string name = *namePtr;
335 dbus::utility::escapePathForDbus(name);
James Feist73df0db2019-03-25 15:29:35 -0700336 }
Ed Tanous711ac7a2021-12-20 09:34:41 -0800337 else if (propPair.first == "Profiles")
James Feist73df0db2019-03-25 15:29:35 -0700338 {
Ed Tanous711ac7a2021-12-20 09:34:41 -0800339 const std::vector<std::string>* profiles =
340 std::get_if<std::vector<std::string>>(
341 &propPair.second);
342 if (profiles == nullptr)
343 {
344 BMCWEB_LOG_ERROR
345 << "Pid Profiles Field illegal";
346 messages::internalError(asyncResp->res);
347 return;
348 }
349 if (std::find(profiles->begin(), profiles->end(),
350 currentProfile) == profiles->end())
351 {
352 BMCWEB_LOG_INFO
353 << name
354 << " not supported in current profile";
355 continue;
356 }
James Feist73df0db2019-03-25 15:29:35 -0700357 }
358 }
James Feistb7a08d02018-12-11 14:55:37 -0800359 nlohmann::json* config = nullptr;
James Feistc33a90e2019-03-01 10:17:44 -0800360 const std::string* classPtr = nullptr;
Ed Tanous711ac7a2021-12-20 09:34:41 -0800361
362 for (const std::pair<std::string,
363 dbus::utility::DbusVariantType>&
364 propPair : intfPair.second)
James Feistc33a90e2019-03-01 10:17:44 -0800365 {
Ed Tanous711ac7a2021-12-20 09:34:41 -0800366 if (intfPair.first == "Class")
367 {
368 classPtr =
369 std::get_if<std::string>(&propPair.second);
370 }
James Feistc33a90e2019-03-01 10:17:44 -0800371 }
372
James Feist5b4aa862018-08-16 14:07:01 -0700373 if (intfPair.first == pidZoneConfigurationIface)
374 {
375 std::string chassis;
376 if (!dbus::utility::getNthStringFromPath(
377 pathPair.first.str, 5, chassis))
378 {
379 chassis = "#IllegalValue";
380 }
381 nlohmann::json& zone = zones[name];
382 zone["Chassis"] = {
383 {"@odata.id", "/redfish/v1/Chassis/" + chassis}};
George Liu0fda0f12021-11-16 10:06:17 +0800384 zone["@odata.id"] =
385 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones/" +
386 name;
James Feist5b4aa862018-08-16 14:07:01 -0700387 zone["@odata.type"] = "#OemManager.FanZone";
James Feistb7a08d02018-12-11 14:55:37 -0800388 config = &zone;
James Feist5b4aa862018-08-16 14:07:01 -0700389 }
390
James Feistb7a08d02018-12-11 14:55:37 -0800391 else if (intfPair.first == stepwiseConfigurationIface)
392 {
James Feistc33a90e2019-03-01 10:17:44 -0800393 if (classPtr == nullptr)
394 {
395 BMCWEB_LOG_ERROR << "Pid Class Field illegal";
396 messages::internalError(asyncResp->res);
397 return;
398 }
399
James Feistb7a08d02018-12-11 14:55:37 -0800400 nlohmann::json& controller = stepwise[name];
401 config = &controller;
402
403 controller["@odata.id"] =
George Liu0fda0f12021-11-16 10:06:17 +0800404 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/StepwiseControllers/" +
Ed Tanous271584a2019-07-09 16:24:22 -0700405 name;
James Feistb7a08d02018-12-11 14:55:37 -0800406 controller["@odata.type"] =
407 "#OemManager.StepwiseController";
408
James Feistc33a90e2019-03-01 10:17:44 -0800409 controller["Direction"] = *classPtr;
James Feistb7a08d02018-12-11 14:55:37 -0800410 }
411
412 // pid and fans are off the same configuration
413 else if (intfPair.first == pidConfigurationIface)
414 {
James Feistc33a90e2019-03-01 10:17:44 -0800415
James Feistb7a08d02018-12-11 14:55:37 -0800416 if (classPtr == nullptr)
417 {
418 BMCWEB_LOG_ERROR << "Pid Class Field illegal";
419 messages::internalError(asyncResp->res);
420 return;
421 }
422 bool isFan = *classPtr == "fan";
423 nlohmann::json& element =
424 isFan ? fans[name] : pids[name];
425 config = &element;
426 if (isFan)
427 {
428 element["@odata.id"] =
George Liu0fda0f12021-11-16 10:06:17 +0800429 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanControllers/" +
Ed Tanous271584a2019-07-09 16:24:22 -0700430 name;
James Feistb7a08d02018-12-11 14:55:37 -0800431 element["@odata.type"] =
432 "#OemManager.FanController";
James Feistb7a08d02018-12-11 14:55:37 -0800433 }
434 else
435 {
436 element["@odata.id"] =
George Liu0fda0f12021-11-16 10:06:17 +0800437 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/PidControllers/" +
Ed Tanous271584a2019-07-09 16:24:22 -0700438 name;
James Feistb7a08d02018-12-11 14:55:37 -0800439 element["@odata.type"] =
440 "#OemManager.PidController";
James Feistb7a08d02018-12-11 14:55:37 -0800441 }
442 }
443 else
444 {
445 BMCWEB_LOG_ERROR << "Unexpected configuration";
446 messages::internalError(asyncResp->res);
447 return;
448 }
449
450 // used for making maps out of 2 vectors
451 const std::vector<double>* keys = nullptr;
452 const std::vector<double>* values = nullptr;
453
James Feist5b4aa862018-08-16 14:07:01 -0700454 for (const auto& propertyPair : intfPair.second)
455 {
456 if (propertyPair.first == "Type" ||
457 propertyPair.first == "Class" ||
458 propertyPair.first == "Name")
459 {
460 continue;
461 }
462
463 // zones
464 if (intfPair.first == pidZoneConfigurationIface)
465 {
Ed Tanous1b6b96c2018-11-30 11:35:41 -0800466 const double* ptr =
Ed Tanousabf2add2019-01-22 16:40:12 -0800467 std::get_if<double>(&propertyPair.second);
James Feist5b4aa862018-08-16 14:07:01 -0700468 if (ptr == nullptr)
469 {
470 BMCWEB_LOG_ERROR << "Field Illegal "
471 << propertyPair.first;
Jason M. Billsf12894f2018-10-09 12:45:45 -0700472 messages::internalError(asyncResp->res);
James Feist5b4aa862018-08-16 14:07:01 -0700473 return;
474 }
James Feistb7a08d02018-12-11 14:55:37 -0800475 (*config)[propertyPair.first] = *ptr;
476 }
477
478 if (intfPair.first == stepwiseConfigurationIface)
479 {
480 if (propertyPair.first == "Reading" ||
481 propertyPair.first == "Output")
482 {
483 const std::vector<double>* ptr =
Ed Tanousabf2add2019-01-22 16:40:12 -0800484 std::get_if<std::vector<double>>(
James Feistb7a08d02018-12-11 14:55:37 -0800485 &propertyPair.second);
486
487 if (ptr == nullptr)
488 {
489 BMCWEB_LOG_ERROR << "Field Illegal "
490 << propertyPair.first;
491 messages::internalError(asyncResp->res);
492 return;
493 }
494
495 if (propertyPair.first == "Reading")
496 {
497 keys = ptr;
498 }
499 else
500 {
501 values = ptr;
502 }
503 if (keys && values)
504 {
505 if (keys->size() != values->size())
506 {
507 BMCWEB_LOG_ERROR
George Liu0fda0f12021-11-16 10:06:17 +0800508 << "Reading and Output size don't match ";
James Feistb7a08d02018-12-11 14:55:37 -0800509 messages::internalError(asyncResp->res);
510 return;
511 }
512 nlohmann::json& steps = (*config)["Steps"];
513 steps = nlohmann::json::array();
514 for (size_t ii = 0; ii < keys->size(); ii++)
515 {
516 steps.push_back(
517 {{"Target", (*keys)[ii]},
518 {"Output", (*values)[ii]}});
519 }
520 }
521 }
522 if (propertyPair.first == "NegativeHysteresis" ||
523 propertyPair.first == "PositiveHysteresis")
524 {
525 const double* ptr =
Ed Tanousabf2add2019-01-22 16:40:12 -0800526 std::get_if<double>(&propertyPair.second);
James Feistb7a08d02018-12-11 14:55:37 -0800527 if (ptr == nullptr)
528 {
529 BMCWEB_LOG_ERROR << "Field Illegal "
530 << propertyPair.first;
531 messages::internalError(asyncResp->res);
532 return;
533 }
534 (*config)[propertyPair.first] = *ptr;
535 }
James Feist5b4aa862018-08-16 14:07:01 -0700536 }
537
538 // pid and fans are off the same configuration
James Feistb7a08d02018-12-11 14:55:37 -0800539 if (intfPair.first == pidConfigurationIface ||
540 intfPair.first == stepwiseConfigurationIface)
James Feist5b4aa862018-08-16 14:07:01 -0700541 {
James Feist5b4aa862018-08-16 14:07:01 -0700542
543 if (propertyPair.first == "Zones")
544 {
545 const std::vector<std::string>* inputs =
Ed Tanousabf2add2019-01-22 16:40:12 -0800546 std::get_if<std::vector<std::string>>(
Ed Tanous1b6b96c2018-11-30 11:35:41 -0800547 &propertyPair.second);
James Feist5b4aa862018-08-16 14:07:01 -0700548
549 if (inputs == nullptr)
550 {
551 BMCWEB_LOG_ERROR
552 << "Zones Pid Field Illegal";
Jason M. Billsa08b46c2018-11-06 15:01:08 -0800553 messages::internalError(asyncResp->res);
James Feist5b4aa862018-08-16 14:07:01 -0700554 return;
555 }
James Feistb7a08d02018-12-11 14:55:37 -0800556 auto& data = (*config)[propertyPair.first];
James Feist5b4aa862018-08-16 14:07:01 -0700557 data = nlohmann::json::array();
558 for (std::string itemCopy : *inputs)
559 {
560 dbus::utility::escapePathForDbus(itemCopy);
561 data.push_back(
562 {{"@odata.id",
George Liu0fda0f12021-11-16 10:06:17 +0800563 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones/" +
James Feist5b4aa862018-08-16 14:07:01 -0700564 itemCopy}});
565 }
566 }
567 // todo(james): may never happen, but this
568 // assumes configuration data referenced in the
569 // PID config is provided by the same daemon, we
570 // could add another loop to cover all cases,
571 // but I'm okay kicking this can down the road a
572 // bit
573
574 else if (propertyPair.first == "Inputs" ||
575 propertyPair.first == "Outputs")
576 {
James Feistb7a08d02018-12-11 14:55:37 -0800577 auto& data = (*config)[propertyPair.first];
James Feist5b4aa862018-08-16 14:07:01 -0700578 const std::vector<std::string>* inputs =
Ed Tanousabf2add2019-01-22 16:40:12 -0800579 std::get_if<std::vector<std::string>>(
Ed Tanous1b6b96c2018-11-30 11:35:41 -0800580 &propertyPair.second);
James Feist5b4aa862018-08-16 14:07:01 -0700581
582 if (inputs == nullptr)
583 {
584 BMCWEB_LOG_ERROR << "Field Illegal "
585 << propertyPair.first;
Jason M. Billsf12894f2018-10-09 12:45:45 -0700586 messages::internalError(asyncResp->res);
James Feist5b4aa862018-08-16 14:07:01 -0700587 return;
588 }
589 data = *inputs;
James Feistb943aae2019-07-11 16:33:56 -0700590 }
591 else if (propertyPair.first == "SetPointOffset")
592 {
593 const std::string* ptr =
594 std::get_if<std::string>(
595 &propertyPair.second);
596
597 if (ptr == nullptr)
598 {
599 BMCWEB_LOG_ERROR << "Field Illegal "
600 << propertyPair.first;
601 messages::internalError(asyncResp->res);
602 return;
603 }
604 // translate from dbus to redfish
605 if (*ptr == "WarningHigh")
606 {
607 (*config)["SetPointOffset"] =
608 "UpperThresholdNonCritical";
609 }
610 else if (*ptr == "WarningLow")
611 {
612 (*config)["SetPointOffset"] =
613 "LowerThresholdNonCritical";
614 }
615 else if (*ptr == "CriticalHigh")
616 {
617 (*config)["SetPointOffset"] =
618 "UpperThresholdCritical";
619 }
620 else if (*ptr == "CriticalLow")
621 {
622 (*config)["SetPointOffset"] =
623 "LowerThresholdCritical";
624 }
625 else
626 {
627 BMCWEB_LOG_ERROR << "Value Illegal "
628 << *ptr;
629 messages::internalError(asyncResp->res);
630 return;
631 }
632 }
633 // doubles
James Feist5b4aa862018-08-16 14:07:01 -0700634 else if (propertyPair.first ==
635 "FFGainCoefficient" ||
636 propertyPair.first == "FFOffCoefficient" ||
637 propertyPair.first == "ICoefficient" ||
638 propertyPair.first == "ILimitMax" ||
639 propertyPair.first == "ILimitMin" ||
James Feistaad1a252019-02-19 10:13:52 -0800640 propertyPair.first ==
641 "PositiveHysteresis" ||
642 propertyPair.first ==
643 "NegativeHysteresis" ||
James Feist5b4aa862018-08-16 14:07:01 -0700644 propertyPair.first == "OutLimitMax" ||
645 propertyPair.first == "OutLimitMin" ||
646 propertyPair.first == "PCoefficient" ||
James Feist7625cb82019-01-23 11:58:21 -0800647 propertyPair.first == "SetPoint" ||
James Feist5b4aa862018-08-16 14:07:01 -0700648 propertyPair.first == "SlewNeg" ||
649 propertyPair.first == "SlewPos")
650 {
651 const double* ptr =
Ed Tanousabf2add2019-01-22 16:40:12 -0800652 std::get_if<double>(&propertyPair.second);
James Feist5b4aa862018-08-16 14:07:01 -0700653 if (ptr == nullptr)
654 {
655 BMCWEB_LOG_ERROR << "Field Illegal "
656 << propertyPair.first;
Jason M. Billsf12894f2018-10-09 12:45:45 -0700657 messages::internalError(asyncResp->res);
James Feist5b4aa862018-08-16 14:07:01 -0700658 return;
659 }
James Feistb7a08d02018-12-11 14:55:37 -0800660 (*config)[propertyPair.first] = *ptr;
James Feist5b4aa862018-08-16 14:07:01 -0700661 }
662 }
663 }
664 }
665 }
666 },
667 connection, path, objectManagerIface, "GetManagedObjects");
668}
Jennifer Leeca537922018-08-10 10:07:30 -0700669
James Feist83ff9ab2018-08-31 10:18:24 -0700670enum class CreatePIDRet
671{
672 fail,
673 del,
674 patch
675};
676
zhanghch058d1b46d2021-04-01 11:18:24 +0800677inline bool
678 getZonesFromJsonReq(const std::shared_ptr<bmcweb::AsyncResp>& response,
679 std::vector<nlohmann::json>& config,
680 std::vector<std::string>& zones)
James Feist5f2caae2018-12-12 14:08:25 -0800681{
James Feistb6baeaa2019-02-21 10:41:40 -0800682 if (config.empty())
683 {
684 BMCWEB_LOG_ERROR << "Empty Zones";
685 messages::propertyValueFormatError(response->res,
686 nlohmann::json::array(), "Zones");
687 return false;
688 }
James Feist5f2caae2018-12-12 14:08:25 -0800689 for (auto& odata : config)
690 {
691 std::string path;
692 if (!redfish::json_util::readJson(odata, response->res, "@odata.id",
693 path))
694 {
695 return false;
696 }
697 std::string input;
James Feist61adbda2019-03-25 13:03:51 -0700698
699 // 8 below comes from
700 // /redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones/Left
701 // 0 1 2 3 4 5 6 7 8
702 if (!dbus::utility::getNthStringFromPath(path, 8, input))
James Feist5f2caae2018-12-12 14:08:25 -0800703 {
704 BMCWEB_LOG_ERROR << "Got invalid path " << path;
705 BMCWEB_LOG_ERROR << "Illegal Type Zones";
706 messages::propertyValueFormatError(response->res, odata.dump(),
707 "Zones");
708 return false;
709 }
710 boost::replace_all(input, "_", " ");
711 zones.emplace_back(std::move(input));
712 }
713 return true;
714}
715
Ed Tanous711ac7a2021-12-20 09:34:41 -0800716inline const dbus::utility::ManagedObjectType::value_type*
James Feist73df0db2019-03-25 15:29:35 -0700717 findChassis(const dbus::utility::ManagedObjectType& managedObj,
718 const std::string& value, std::string& chassis)
James Feistb6baeaa2019-02-21 10:41:40 -0800719{
720 BMCWEB_LOG_DEBUG << "Find Chassis: " << value << "\n";
721
722 std::string escaped = boost::replace_all_copy(value, " ", "_");
723 escaped = "/" + escaped;
724 auto it = std::find_if(
725 managedObj.begin(), managedObj.end(), [&escaped](const auto& obj) {
726 if (boost::algorithm::ends_with(obj.first.str, escaped))
727 {
728 BMCWEB_LOG_DEBUG << "Matched " << obj.first.str << "\n";
729 return true;
730 }
731 return false;
732 });
733
734 if (it == managedObj.end())
735 {
James Feist73df0db2019-03-25 15:29:35 -0700736 return nullptr;
James Feistb6baeaa2019-02-21 10:41:40 -0800737 }
738 // 5 comes from <chassis-name> being the 5th element
739 // /xyz/openbmc_project/inventory/system/chassis/<chassis-name>
James Feist73df0db2019-03-25 15:29:35 -0700740 if (dbus::utility::getNthStringFromPath(it->first.str, 5, chassis))
741 {
742 return &(*it);
743 }
744
745 return nullptr;
James Feistb6baeaa2019-02-21 10:41:40 -0800746}
747
Ed Tanous23a21a12020-07-25 04:45:05 +0000748inline CreatePIDRet createPidInterface(
zhanghch058d1b46d2021-04-01 11:18:24 +0800749 const std::shared_ptr<bmcweb::AsyncResp>& response, const std::string& type,
Ed Tanousb5a76932020-09-29 16:16:58 -0700750 const nlohmann::json::iterator& it, const std::string& path,
James Feist83ff9ab2018-08-31 10:18:24 -0700751 const dbus::utility::ManagedObjectType& managedObj, bool createNewObject,
752 boost::container::flat_map<std::string, dbus::utility::DbusVariantType>&
753 output,
James Feist73df0db2019-03-25 15:29:35 -0700754 std::string& chassis, const std::string& profile)
James Feist83ff9ab2018-08-31 10:18:24 -0700755{
756
James Feist5f2caae2018-12-12 14:08:25 -0800757 // common deleter
James Feistb6baeaa2019-02-21 10:41:40 -0800758 if (it.value() == nullptr)
James Feist5f2caae2018-12-12 14:08:25 -0800759 {
760 std::string iface;
761 if (type == "PidControllers" || type == "FanControllers")
762 {
763 iface = pidConfigurationIface;
764 }
765 else if (type == "FanZones")
766 {
767 iface = pidZoneConfigurationIface;
768 }
769 else if (type == "StepwiseControllers")
770 {
771 iface = stepwiseConfigurationIface;
772 }
773 else
774 {
Gunnar Millsa0744d32020-11-09 15:40:45 -0600775 BMCWEB_LOG_ERROR << "Illegal Type " << type;
James Feist5f2caae2018-12-12 14:08:25 -0800776 messages::propertyUnknown(response->res, type);
777 return CreatePIDRet::fail;
778 }
James Feist6ee7f772020-02-06 16:25:27 -0800779
780 BMCWEB_LOG_DEBUG << "del " << path << " " << iface << "\n";
James Feist5f2caae2018-12-12 14:08:25 -0800781 // delete interface
782 crow::connections::systemBus->async_method_call(
783 [response, path](const boost::system::error_code ec) {
784 if (ec)
785 {
786 BMCWEB_LOG_ERROR << "Error patching " << path << ": " << ec;
787 messages::internalError(response->res);
James Feistb6baeaa2019-02-21 10:41:40 -0800788 return;
James Feist5f2caae2018-12-12 14:08:25 -0800789 }
James Feistb6baeaa2019-02-21 10:41:40 -0800790 messages::success(response->res);
James Feist5f2caae2018-12-12 14:08:25 -0800791 },
792 "xyz.openbmc_project.EntityManager", path, iface, "Delete");
793 return CreatePIDRet::del;
794 }
795
Ed Tanous711ac7a2021-12-20 09:34:41 -0800796 const dbus::utility::ManagedObjectType::value_type* managedItem = nullptr;
James Feistb6baeaa2019-02-21 10:41:40 -0800797 if (!createNewObject)
798 {
799 // if we aren't creating a new object, we should be able to find it on
800 // d-bus
James Feist73df0db2019-03-25 15:29:35 -0700801 managedItem = findChassis(managedObj, it.key(), chassis);
802 if (managedItem == nullptr)
James Feistb6baeaa2019-02-21 10:41:40 -0800803 {
804 BMCWEB_LOG_ERROR << "Failed to get chassis from config patch";
805 messages::invalidObject(response->res, it.key());
806 return CreatePIDRet::fail;
807 }
808 }
809
James Feist73df0db2019-03-25 15:29:35 -0700810 if (profile.size() &&
811 (type == "PidControllers" || type == "FanControllers" ||
812 type == "StepwiseControllers"))
813 {
814 if (managedItem == nullptr)
815 {
816 output["Profiles"] = std::vector<std::string>{profile};
817 }
818 else
819 {
820 std::string interface;
821 if (type == "StepwiseControllers")
822 {
823 interface = stepwiseConfigurationIface;
824 }
825 else
826 {
827 interface = pidConfigurationIface;
828 }
Ed Tanous711ac7a2021-12-20 09:34:41 -0800829 bool ifaceFound = false;
830 for (const auto& iface : managedItem->second)
831 {
832 if (iface.first == interface)
833 {
834 ifaceFound = true;
835 for (const auto& prop : iface.second)
836 {
837 if (prop.first == "Profiles")
838 {
839 const std::vector<std::string>* curProfiles =
840 std::get_if<std::vector<std::string>>(
841 &(prop.second));
842 if (curProfiles == nullptr)
843 {
844 BMCWEB_LOG_ERROR
845 << "Illegal profiles in managed object";
846 messages::internalError(response->res);
847 return CreatePIDRet::fail;
848 }
849 if (std::find(curProfiles->begin(),
850 curProfiles->end(),
851 profile) == curProfiles->end())
852 {
853 std::vector<std::string> newProfiles =
854 *curProfiles;
855 newProfiles.push_back(profile);
856 output["Profiles"] = newProfiles;
857 }
858 }
859 }
860 }
861 }
862
863 if (!ifaceFound)
James Feist73df0db2019-03-25 15:29:35 -0700864 {
865 BMCWEB_LOG_ERROR
866 << "Failed to find interface in managed object";
867 messages::internalError(response->res);
868 return CreatePIDRet::fail;
869 }
James Feist73df0db2019-03-25 15:29:35 -0700870 }
871 }
872
James Feist83ff9ab2018-08-31 10:18:24 -0700873 if (type == "PidControllers" || type == "FanControllers")
874 {
875 if (createNewObject)
876 {
877 output["Class"] = type == "PidControllers" ? std::string("temp")
878 : std::string("fan");
879 output["Type"] = std::string("Pid");
880 }
James Feist5f2caae2018-12-12 14:08:25 -0800881
882 std::optional<std::vector<nlohmann::json>> zones;
883 std::optional<std::vector<std::string>> inputs;
884 std::optional<std::vector<std::string>> outputs;
885 std::map<std::string, std::optional<double>> doubles;
James Feistb943aae2019-07-11 16:33:56 -0700886 std::optional<std::string> setpointOffset;
James Feist5f2caae2018-12-12 14:08:25 -0800887 if (!redfish::json_util::readJson(
James Feistb6baeaa2019-02-21 10:41:40 -0800888 it.value(), response->res, "Inputs", inputs, "Outputs", outputs,
James Feist5f2caae2018-12-12 14:08:25 -0800889 "Zones", zones, "FFGainCoefficient",
890 doubles["FFGainCoefficient"], "FFOffCoefficient",
891 doubles["FFOffCoefficient"], "ICoefficient",
892 doubles["ICoefficient"], "ILimitMax", doubles["ILimitMax"],
893 "ILimitMin", doubles["ILimitMin"], "OutLimitMax",
894 doubles["OutLimitMax"], "OutLimitMin", doubles["OutLimitMin"],
895 "PCoefficient", doubles["PCoefficient"], "SetPoint",
James Feistb943aae2019-07-11 16:33:56 -0700896 doubles["SetPoint"], "SetPointOffset", setpointOffset,
897 "SlewNeg", doubles["SlewNeg"], "SlewPos", doubles["SlewPos"],
898 "PositiveHysteresis", doubles["PositiveHysteresis"],
899 "NegativeHysteresis", doubles["NegativeHysteresis"]))
James Feist83ff9ab2018-08-31 10:18:24 -0700900 {
Ed Tanous71f52d92021-02-19 08:51:17 -0800901 BMCWEB_LOG_ERROR
902 << "Illegal Property "
903 << it.value().dump(2, ' ', true,
904 nlohmann::json::error_handler_t::replace);
James Feist5f2caae2018-12-12 14:08:25 -0800905 return CreatePIDRet::fail;
James Feist83ff9ab2018-08-31 10:18:24 -0700906 }
James Feist5f2caae2018-12-12 14:08:25 -0800907 if (zones)
James Feist83ff9ab2018-08-31 10:18:24 -0700908 {
James Feist5f2caae2018-12-12 14:08:25 -0800909 std::vector<std::string> zonesStr;
910 if (!getZonesFromJsonReq(response, *zones, zonesStr))
James Feist83ff9ab2018-08-31 10:18:24 -0700911 {
Gunnar Millsa0744d32020-11-09 15:40:45 -0600912 BMCWEB_LOG_ERROR << "Illegal Zones";
James Feist5f2caae2018-12-12 14:08:25 -0800913 return CreatePIDRet::fail;
James Feist83ff9ab2018-08-31 10:18:24 -0700914 }
James Feistb6baeaa2019-02-21 10:41:40 -0800915 if (chassis.empty() &&
916 !findChassis(managedObj, zonesStr[0], chassis))
917 {
918 BMCWEB_LOG_ERROR << "Failed to get chassis from config patch";
919 messages::invalidObject(response->res, it.key());
920 return CreatePIDRet::fail;
921 }
922
James Feist5f2caae2018-12-12 14:08:25 -0800923 output["Zones"] = std::move(zonesStr);
924 }
925 if (inputs || outputs)
926 {
927 std::array<std::optional<std::vector<std::string>>*, 2> containers =
928 {&inputs, &outputs};
929 size_t index = 0;
930 for (const auto& containerPtr : containers)
James Feist83ff9ab2018-08-31 10:18:24 -0700931 {
James Feist5f2caae2018-12-12 14:08:25 -0800932 std::optional<std::vector<std::string>>& container =
933 *containerPtr;
934 if (!container)
James Feist83ff9ab2018-08-31 10:18:24 -0700935 {
James Feist5f2caae2018-12-12 14:08:25 -0800936 index++;
937 continue;
James Feist83ff9ab2018-08-31 10:18:24 -0700938 }
James Feist5f2caae2018-12-12 14:08:25 -0800939
940 for (std::string& value : *container)
James Feist83ff9ab2018-08-31 10:18:24 -0700941 {
James Feist5f2caae2018-12-12 14:08:25 -0800942 boost::replace_all(value, "_", " ");
James Feist83ff9ab2018-08-31 10:18:24 -0700943 }
James Feist5f2caae2018-12-12 14:08:25 -0800944 std::string key;
945 if (index == 0)
James Feist83ff9ab2018-08-31 10:18:24 -0700946 {
James Feist5f2caae2018-12-12 14:08:25 -0800947 key = "Inputs";
James Feist83ff9ab2018-08-31 10:18:24 -0700948 }
James Feist5f2caae2018-12-12 14:08:25 -0800949 else
950 {
951 key = "Outputs";
952 }
953 output[key] = *container;
954 index++;
James Feist83ff9ab2018-08-31 10:18:24 -0700955 }
James Feist5f2caae2018-12-12 14:08:25 -0800956 }
James Feist83ff9ab2018-08-31 10:18:24 -0700957
James Feistb943aae2019-07-11 16:33:56 -0700958 if (setpointOffset)
959 {
960 // translate between redfish and dbus names
961 if (*setpointOffset == "UpperThresholdNonCritical")
962 {
963 output["SetPointOffset"] = std::string("WarningLow");
964 }
965 else if (*setpointOffset == "LowerThresholdNonCritical")
966 {
967 output["SetPointOffset"] = std::string("WarningHigh");
968 }
969 else if (*setpointOffset == "LowerThresholdCritical")
970 {
971 output["SetPointOffset"] = std::string("CriticalLow");
972 }
973 else if (*setpointOffset == "UpperThresholdCritical")
974 {
975 output["SetPointOffset"] = std::string("CriticalHigh");
976 }
977 else
978 {
979 BMCWEB_LOG_ERROR << "Invalid setpointoffset "
980 << *setpointOffset;
981 messages::invalidObject(response->res, it.key());
982 return CreatePIDRet::fail;
983 }
984 }
985
James Feist5f2caae2018-12-12 14:08:25 -0800986 // doubles
987 for (const auto& pairs : doubles)
988 {
989 if (!pairs.second)
James Feist83ff9ab2018-08-31 10:18:24 -0700990 {
James Feist5f2caae2018-12-12 14:08:25 -0800991 continue;
James Feist83ff9ab2018-08-31 10:18:24 -0700992 }
James Feist5f2caae2018-12-12 14:08:25 -0800993 BMCWEB_LOG_DEBUG << pairs.first << " = " << *pairs.second;
994 output[pairs.first] = *(pairs.second);
James Feist83ff9ab2018-08-31 10:18:24 -0700995 }
996 }
James Feist5f2caae2018-12-12 14:08:25 -0800997
James Feist83ff9ab2018-08-31 10:18:24 -0700998 else if (type == "FanZones")
999 {
James Feist83ff9ab2018-08-31 10:18:24 -07001000 output["Type"] = std::string("Pid.Zone");
1001
James Feist5f2caae2018-12-12 14:08:25 -08001002 std::optional<nlohmann::json> chassisContainer;
1003 std::optional<double> failSafePercent;
James Feistd3ec07f2019-02-25 14:51:15 -08001004 std::optional<double> minThermalOutput;
James Feistb6baeaa2019-02-21 10:41:40 -08001005 if (!redfish::json_util::readJson(it.value(), response->res, "Chassis",
James Feist5f2caae2018-12-12 14:08:25 -08001006 chassisContainer, "FailSafePercent",
James Feistd3ec07f2019-02-25 14:51:15 -08001007 failSafePercent, "MinThermalOutput",
1008 minThermalOutput))
James Feist83ff9ab2018-08-31 10:18:24 -07001009 {
Ed Tanous71f52d92021-02-19 08:51:17 -08001010 BMCWEB_LOG_ERROR
1011 << "Illegal Property "
1012 << it.value().dump(2, ' ', true,
1013 nlohmann::json::error_handler_t::replace);
James Feist5f2caae2018-12-12 14:08:25 -08001014 return CreatePIDRet::fail;
1015 }
James Feist83ff9ab2018-08-31 10:18:24 -07001016
James Feist5f2caae2018-12-12 14:08:25 -08001017 if (chassisContainer)
1018 {
1019
1020 std::string chassisId;
1021 if (!redfish::json_util::readJson(*chassisContainer, response->res,
1022 "@odata.id", chassisId))
James Feist83ff9ab2018-08-31 10:18:24 -07001023 {
Ed Tanous71f52d92021-02-19 08:51:17 -08001024 BMCWEB_LOG_ERROR
1025 << "Illegal Property "
1026 << chassisContainer->dump(
1027 2, ' ', true,
1028 nlohmann::json::error_handler_t::replace);
James Feist83ff9ab2018-08-31 10:18:24 -07001029 return CreatePIDRet::fail;
1030 }
James Feist5f2caae2018-12-12 14:08:25 -08001031
AppaRao Puli717794d2019-10-18 22:54:53 +05301032 // /redfish/v1/chassis/chassis_name/
James Feist5f2caae2018-12-12 14:08:25 -08001033 if (!dbus::utility::getNthStringFromPath(chassisId, 3, chassis))
1034 {
1035 BMCWEB_LOG_ERROR << "Got invalid path " << chassisId;
1036 messages::invalidObject(response->res, chassisId);
1037 return CreatePIDRet::fail;
1038 }
1039 }
James Feistd3ec07f2019-02-25 14:51:15 -08001040 if (minThermalOutput)
James Feist5f2caae2018-12-12 14:08:25 -08001041 {
James Feistd3ec07f2019-02-25 14:51:15 -08001042 output["MinThermalOutput"] = *minThermalOutput;
James Feist5f2caae2018-12-12 14:08:25 -08001043 }
1044 if (failSafePercent)
1045 {
1046 output["FailSafePercent"] = *failSafePercent;
1047 }
1048 }
1049 else if (type == "StepwiseControllers")
1050 {
1051 output["Type"] = std::string("Stepwise");
1052
1053 std::optional<std::vector<nlohmann::json>> zones;
1054 std::optional<std::vector<nlohmann::json>> steps;
1055 std::optional<std::vector<std::string>> inputs;
1056 std::optional<double> positiveHysteresis;
1057 std::optional<double> negativeHysteresis;
James Feistc33a90e2019-03-01 10:17:44 -08001058 std::optional<std::string> direction; // upper clipping curve vs lower
James Feist5f2caae2018-12-12 14:08:25 -08001059 if (!redfish::json_util::readJson(
James Feistb6baeaa2019-02-21 10:41:40 -08001060 it.value(), response->res, "Zones", zones, "Steps", steps,
1061 "Inputs", inputs, "PositiveHysteresis", positiveHysteresis,
James Feistc33a90e2019-03-01 10:17:44 -08001062 "NegativeHysteresis", negativeHysteresis, "Direction",
1063 direction))
James Feist5f2caae2018-12-12 14:08:25 -08001064 {
Ed Tanous71f52d92021-02-19 08:51:17 -08001065 BMCWEB_LOG_ERROR
1066 << "Illegal Property "
1067 << it.value().dump(2, ' ', true,
1068 nlohmann::json::error_handler_t::replace);
James Feist5f2caae2018-12-12 14:08:25 -08001069 return CreatePIDRet::fail;
1070 }
1071
1072 if (zones)
1073 {
James Feistb6baeaa2019-02-21 10:41:40 -08001074 std::vector<std::string> zonesStrs;
1075 if (!getZonesFromJsonReq(response, *zones, zonesStrs))
James Feist5f2caae2018-12-12 14:08:25 -08001076 {
Gunnar Millsa0744d32020-11-09 15:40:45 -06001077 BMCWEB_LOG_ERROR << "Illegal Zones";
James Feist5f2caae2018-12-12 14:08:25 -08001078 return CreatePIDRet::fail;
1079 }
James Feistb6baeaa2019-02-21 10:41:40 -08001080 if (chassis.empty() &&
1081 !findChassis(managedObj, zonesStrs[0], chassis))
1082 {
1083 BMCWEB_LOG_ERROR << "Failed to get chassis from config patch";
1084 messages::invalidObject(response->res, it.key());
1085 return CreatePIDRet::fail;
1086 }
1087 output["Zones"] = std::move(zonesStrs);
James Feist5f2caae2018-12-12 14:08:25 -08001088 }
1089 if (steps)
1090 {
1091 std::vector<double> readings;
1092 std::vector<double> outputs;
1093 for (auto& step : *steps)
1094 {
Ed Tanous543f4402022-01-06 13:12:53 -08001095 double target = 0.0;
1096 double out = 0.0;
James Feist5f2caae2018-12-12 14:08:25 -08001097
1098 if (!redfish::json_util::readJson(step, response->res, "Target",
Ed Tanous23a21a12020-07-25 04:45:05 +00001099 target, "Output", out))
James Feist5f2caae2018-12-12 14:08:25 -08001100 {
Ed Tanous71f52d92021-02-19 08:51:17 -08001101 BMCWEB_LOG_ERROR
1102 << "Illegal Property "
1103 << it.value().dump(
1104 2, ' ', true,
1105 nlohmann::json::error_handler_t::replace);
James Feist5f2caae2018-12-12 14:08:25 -08001106 return CreatePIDRet::fail;
1107 }
1108 readings.emplace_back(target);
Ed Tanous23a21a12020-07-25 04:45:05 +00001109 outputs.emplace_back(out);
James Feist5f2caae2018-12-12 14:08:25 -08001110 }
1111 output["Reading"] = std::move(readings);
1112 output["Output"] = std::move(outputs);
1113 }
1114 if (inputs)
1115 {
1116 for (std::string& value : *inputs)
1117 {
James Feist5f2caae2018-12-12 14:08:25 -08001118 boost::replace_all(value, "_", " ");
1119 }
1120 output["Inputs"] = std::move(*inputs);
1121 }
1122 if (negativeHysteresis)
1123 {
1124 output["NegativeHysteresis"] = *negativeHysteresis;
1125 }
1126 if (positiveHysteresis)
1127 {
1128 output["PositiveHysteresis"] = *positiveHysteresis;
James Feist83ff9ab2018-08-31 10:18:24 -07001129 }
James Feistc33a90e2019-03-01 10:17:44 -08001130 if (direction)
1131 {
1132 constexpr const std::array<const char*, 2> allowedDirections = {
1133 "Ceiling", "Floor"};
1134 if (std::find(allowedDirections.begin(), allowedDirections.end(),
1135 *direction) == allowedDirections.end())
1136 {
1137 messages::propertyValueTypeError(response->res, "Direction",
1138 *direction);
1139 return CreatePIDRet::fail;
1140 }
1141 output["Class"] = *direction;
1142 }
James Feist83ff9ab2018-08-31 10:18:24 -07001143 }
1144 else
1145 {
Gunnar Millsa0744d32020-11-09 15:40:45 -06001146 BMCWEB_LOG_ERROR << "Illegal Type " << type;
Jason M. Bills35a62c72018-10-09 12:45:45 -07001147 messages::propertyUnknown(response->res, type);
James Feist83ff9ab2018-08-31 10:18:24 -07001148 return CreatePIDRet::fail;
1149 }
1150 return CreatePIDRet::patch;
1151}
James Feist73df0db2019-03-25 15:29:35 -07001152struct GetPIDValues : std::enable_shared_from_this<GetPIDValues>
1153{
1154
zhanghch058d1b46d2021-04-01 11:18:24 +08001155 GetPIDValues(const std::shared_ptr<bmcweb::AsyncResp>& asyncRespIn) :
Ed Tanous23a21a12020-07-25 04:45:05 +00001156 asyncResp(asyncRespIn)
James Feist73df0db2019-03-25 15:29:35 -07001157
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001158 {}
James Feist73df0db2019-03-25 15:29:35 -07001159
1160 void run()
1161 {
1162 std::shared_ptr<GetPIDValues> self = shared_from_this();
1163
1164 // get all configurations
1165 crow::connections::systemBus->async_method_call(
1166 [self](const boost::system::error_code ec,
Ed Tanous23a21a12020-07-25 04:45:05 +00001167 const crow::openbmc_mapper::GetSubTreeType& subtreeLocal) {
James Feist73df0db2019-03-25 15:29:35 -07001168 if (ec)
1169 {
1170 BMCWEB_LOG_ERROR << ec;
1171 messages::internalError(self->asyncResp->res);
1172 return;
1173 }
Ed Tanous23a21a12020-07-25 04:45:05 +00001174 self->subtree = subtreeLocal;
James Feist73df0db2019-03-25 15:29:35 -07001175 },
1176 "xyz.openbmc_project.ObjectMapper",
1177 "/xyz/openbmc_project/object_mapper",
1178 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0,
1179 std::array<const char*, 4>{
1180 pidConfigurationIface, pidZoneConfigurationIface,
1181 objectManagerIface, stepwiseConfigurationIface});
1182
1183 // at the same time get the selected profile
1184 crow::connections::systemBus->async_method_call(
1185 [self](const boost::system::error_code ec,
Ed Tanous23a21a12020-07-25 04:45:05 +00001186 const crow::openbmc_mapper::GetSubTreeType& subtreeLocal) {
1187 if (ec || subtreeLocal.empty())
James Feist73df0db2019-03-25 15:29:35 -07001188 {
1189 return;
1190 }
Ed Tanous23a21a12020-07-25 04:45:05 +00001191 if (subtreeLocal[0].second.size() != 1)
James Feist73df0db2019-03-25 15:29:35 -07001192 {
1193 // invalid mapper response, should never happen
1194 BMCWEB_LOG_ERROR << "GetPIDValues: Mapper Error";
1195 messages::internalError(self->asyncResp->res);
1196 return;
1197 }
1198
Ed Tanous23a21a12020-07-25 04:45:05 +00001199 const std::string& path = subtreeLocal[0].first;
1200 const std::string& owner = subtreeLocal[0].second[0].first;
James Feist73df0db2019-03-25 15:29:35 -07001201 crow::connections::systemBus->async_method_call(
Ed Tanous168e20c2021-12-13 14:39:53 -08001202 [path, owner,
1203 self](const boost::system::error_code ec2,
1204 const boost::container::flat_map<
1205 std::string, dbus::utility::DbusVariantType>&
1206 resp) {
Ed Tanous23a21a12020-07-25 04:45:05 +00001207 if (ec2)
James Feist73df0db2019-03-25 15:29:35 -07001208 {
George Liu0fda0f12021-11-16 10:06:17 +08001209 BMCWEB_LOG_ERROR
1210 << "GetPIDValues: Can't get thermalModeIface "
1211 << path;
James Feist73df0db2019-03-25 15:29:35 -07001212 messages::internalError(self->asyncResp->res);
1213 return;
1214 }
Ed Tanous271584a2019-07-09 16:24:22 -07001215 const std::string* current = nullptr;
1216 const std::vector<std::string>* supported = nullptr;
James Feist73df0db2019-03-25 15:29:35 -07001217 for (auto& [key, value] : resp)
1218 {
1219 if (key == "Current")
1220 {
1221 current = std::get_if<std::string>(&value);
1222 if (current == nullptr)
1223 {
1224 BMCWEB_LOG_ERROR
George Liu0fda0f12021-11-16 10:06:17 +08001225 << "GetPIDValues: thermal mode iface invalid "
James Feist73df0db2019-03-25 15:29:35 -07001226 << path;
1227 messages::internalError(
1228 self->asyncResp->res);
1229 return;
1230 }
1231 }
1232 if (key == "Supported")
1233 {
1234 supported =
1235 std::get_if<std::vector<std::string>>(
1236 &value);
1237 if (supported == nullptr)
1238 {
1239 BMCWEB_LOG_ERROR
George Liu0fda0f12021-11-16 10:06:17 +08001240 << "GetPIDValues: thermal mode iface invalid"
James Feist73df0db2019-03-25 15:29:35 -07001241 << path;
1242 messages::internalError(
1243 self->asyncResp->res);
1244 return;
1245 }
1246 }
1247 }
1248 if (current == nullptr || supported == nullptr)
1249 {
George Liu0fda0f12021-11-16 10:06:17 +08001250 BMCWEB_LOG_ERROR
1251 << "GetPIDValues: thermal mode iface invalid "
1252 << path;
James Feist73df0db2019-03-25 15:29:35 -07001253 messages::internalError(self->asyncResp->res);
1254 return;
1255 }
1256 self->currentProfile = *current;
1257 self->supportedProfiles = *supported;
1258 },
1259 owner, path, "org.freedesktop.DBus.Properties", "GetAll",
1260 thermalModeIface);
1261 },
1262 "xyz.openbmc_project.ObjectMapper",
1263 "/xyz/openbmc_project/object_mapper",
1264 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0,
1265 std::array<const char*, 1>{thermalModeIface});
1266 }
1267
1268 ~GetPIDValues()
1269 {
1270 if (asyncResp->res.result() != boost::beast::http::status::ok)
1271 {
1272 return;
1273 }
1274 // create map of <connection, path to objMgr>>
1275 boost::container::flat_map<std::string, std::string> objectMgrPaths;
1276 boost::container::flat_set<std::string> calledConnections;
1277 for (const auto& pathGroup : subtree)
1278 {
1279 for (const auto& connectionGroup : pathGroup.second)
1280 {
1281 auto findConnection =
1282 calledConnections.find(connectionGroup.first);
1283 if (findConnection != calledConnections.end())
1284 {
1285 break;
1286 }
1287 for (const std::string& interface : connectionGroup.second)
1288 {
1289 if (interface == objectManagerIface)
1290 {
1291 objectMgrPaths[connectionGroup.first] = pathGroup.first;
1292 }
1293 // this list is alphabetical, so we
1294 // should have found the objMgr by now
1295 if (interface == pidConfigurationIface ||
1296 interface == pidZoneConfigurationIface ||
1297 interface == stepwiseConfigurationIface)
1298 {
1299 auto findObjMgr =
1300 objectMgrPaths.find(connectionGroup.first);
1301 if (findObjMgr == objectMgrPaths.end())
1302 {
1303 BMCWEB_LOG_DEBUG << connectionGroup.first
1304 << "Has no Object Manager";
1305 continue;
1306 }
1307
1308 calledConnections.insert(connectionGroup.first);
1309
1310 asyncPopulatePid(findObjMgr->first, findObjMgr->second,
1311 currentProfile, supportedProfiles,
1312 asyncResp);
1313 break;
1314 }
1315 }
1316 }
1317 }
1318 }
1319
Ed Tanousecd6a3a2022-01-07 09:18:40 -08001320 GetPIDValues(const GetPIDValues&) = delete;
1321 GetPIDValues(GetPIDValues&&) = delete;
1322 GetPIDValues& operator=(const GetPIDValues&) = delete;
1323 GetPIDValues& operator=(GetPIDValues&&) = delete;
1324
James Feist73df0db2019-03-25 15:29:35 -07001325 std::vector<std::string> supportedProfiles;
1326 std::string currentProfile;
1327 crow::openbmc_mapper::GetSubTreeType subtree;
zhanghch058d1b46d2021-04-01 11:18:24 +08001328 std::shared_ptr<bmcweb::AsyncResp> asyncResp;
James Feist73df0db2019-03-25 15:29:35 -07001329};
1330
1331struct SetPIDValues : std::enable_shared_from_this<SetPIDValues>
1332{
1333
zhanghch058d1b46d2021-04-01 11:18:24 +08001334 SetPIDValues(const std::shared_ptr<bmcweb::AsyncResp>& asyncRespIn,
James Feist73df0db2019-03-25 15:29:35 -07001335 nlohmann::json& data) :
Ed Tanous271584a2019-07-09 16:24:22 -07001336 asyncResp(asyncRespIn)
James Feist73df0db2019-03-25 15:29:35 -07001337 {
1338
1339 std::optional<nlohmann::json> pidControllers;
1340 std::optional<nlohmann::json> fanControllers;
1341 std::optional<nlohmann::json> fanZones;
1342 std::optional<nlohmann::json> stepwiseControllers;
1343
1344 if (!redfish::json_util::readJson(
1345 data, asyncResp->res, "PidControllers", pidControllers,
1346 "FanControllers", fanControllers, "FanZones", fanZones,
1347 "StepwiseControllers", stepwiseControllers, "Profile", profile))
1348 {
Ed Tanous71f52d92021-02-19 08:51:17 -08001349 BMCWEB_LOG_ERROR
1350 << "Illegal Property "
1351 << data.dump(2, ' ', true,
1352 nlohmann::json::error_handler_t::replace);
James Feist73df0db2019-03-25 15:29:35 -07001353 return;
1354 }
1355 configuration.emplace_back("PidControllers", std::move(pidControllers));
1356 configuration.emplace_back("FanControllers", std::move(fanControllers));
1357 configuration.emplace_back("FanZones", std::move(fanZones));
1358 configuration.emplace_back("StepwiseControllers",
1359 std::move(stepwiseControllers));
1360 }
Ed Tanousecd6a3a2022-01-07 09:18:40 -08001361
1362 SetPIDValues(const SetPIDValues&) = delete;
1363 SetPIDValues(SetPIDValues&&) = delete;
1364 SetPIDValues& operator=(const SetPIDValues&) = delete;
1365 SetPIDValues& operator=(SetPIDValues&&) = delete;
1366
James Feist73df0db2019-03-25 15:29:35 -07001367 void run()
1368 {
1369 if (asyncResp->res.result() != boost::beast::http::status::ok)
1370 {
1371 return;
1372 }
1373
1374 std::shared_ptr<SetPIDValues> self = shared_from_this();
1375
1376 // todo(james): might make sense to do a mapper call here if this
1377 // interface gets more traction
1378 crow::connections::systemBus->async_method_call(
1379 [self](const boost::system::error_code ec,
Ed Tanous914e2d52022-01-07 11:38:34 -08001380 const dbus::utility::ManagedObjectType& mObj) {
James Feist73df0db2019-03-25 15:29:35 -07001381 if (ec)
1382 {
1383 BMCWEB_LOG_ERROR << "Error communicating to Entity Manager";
1384 messages::internalError(self->asyncResp->res);
1385 return;
1386 }
James Feiste69d9de2020-02-07 12:23:27 -08001387 const std::array<const char*, 3> configurations = {
1388 pidConfigurationIface, pidZoneConfigurationIface,
1389 stepwiseConfigurationIface};
1390
James Feist14b0b8d2020-02-12 11:52:07 -08001391 for (const auto& [path, object] : mObj)
James Feiste69d9de2020-02-07 12:23:27 -08001392 {
James Feist14b0b8d2020-02-12 11:52:07 -08001393 for (const auto& [interface, _] : object)
James Feiste69d9de2020-02-07 12:23:27 -08001394 {
1395 if (std::find(configurations.begin(),
1396 configurations.end(),
1397 interface) != configurations.end())
1398 {
James Feist14b0b8d2020-02-12 11:52:07 -08001399 self->objectCount++;
James Feiste69d9de2020-02-07 12:23:27 -08001400 break;
1401 }
1402 }
James Feiste69d9de2020-02-07 12:23:27 -08001403 }
Ed Tanous914e2d52022-01-07 11:38:34 -08001404 self->managedObj = mObj;
James Feist73df0db2019-03-25 15:29:35 -07001405 },
1406 "xyz.openbmc_project.EntityManager", "/", objectManagerIface,
1407 "GetManagedObjects");
1408
1409 // at the same time get the profile information
1410 crow::connections::systemBus->async_method_call(
1411 [self](const boost::system::error_code ec,
1412 const crow::openbmc_mapper::GetSubTreeType& subtree) {
1413 if (ec || subtree.empty())
1414 {
1415 return;
1416 }
1417 if (subtree[0].second.empty())
1418 {
1419 // invalid mapper response, should never happen
1420 BMCWEB_LOG_ERROR << "SetPIDValues: Mapper Error";
1421 messages::internalError(self->asyncResp->res);
1422 return;
1423 }
1424
1425 const std::string& path = subtree[0].first;
1426 const std::string& owner = subtree[0].second[0].first;
1427 crow::connections::systemBus->async_method_call(
1428 [self, path, owner](
Ed Tanouscb13a392020-07-25 19:02:03 +00001429 const boost::system::error_code ec2,
James Feist73df0db2019-03-25 15:29:35 -07001430 const boost::container::flat_map<
Ed Tanous168e20c2021-12-13 14:39:53 -08001431 std::string, dbus::utility::DbusVariantType>& r) {
Ed Tanouscb13a392020-07-25 19:02:03 +00001432 if (ec2)
James Feist73df0db2019-03-25 15:29:35 -07001433 {
George Liu0fda0f12021-11-16 10:06:17 +08001434 BMCWEB_LOG_ERROR
1435 << "SetPIDValues: Can't get thermalModeIface "
1436 << path;
James Feist73df0db2019-03-25 15:29:35 -07001437 messages::internalError(self->asyncResp->res);
1438 return;
1439 }
Ed Tanous271584a2019-07-09 16:24:22 -07001440 const std::string* current = nullptr;
1441 const std::vector<std::string>* supported = nullptr;
1442 for (auto& [key, value] : r)
James Feist73df0db2019-03-25 15:29:35 -07001443 {
1444 if (key == "Current")
1445 {
1446 current = std::get_if<std::string>(&value);
1447 if (current == nullptr)
1448 {
1449 BMCWEB_LOG_ERROR
George Liu0fda0f12021-11-16 10:06:17 +08001450 << "SetPIDValues: thermal mode iface invalid "
James Feist73df0db2019-03-25 15:29:35 -07001451 << path;
1452 messages::internalError(
1453 self->asyncResp->res);
1454 return;
1455 }
1456 }
1457 if (key == "Supported")
1458 {
1459 supported =
1460 std::get_if<std::vector<std::string>>(
1461 &value);
1462 if (supported == nullptr)
1463 {
1464 BMCWEB_LOG_ERROR
George Liu0fda0f12021-11-16 10:06:17 +08001465 << "SetPIDValues: thermal mode iface invalid"
James Feist73df0db2019-03-25 15:29:35 -07001466 << path;
1467 messages::internalError(
1468 self->asyncResp->res);
1469 return;
1470 }
1471 }
1472 }
1473 if (current == nullptr || supported == nullptr)
1474 {
George Liu0fda0f12021-11-16 10:06:17 +08001475 BMCWEB_LOG_ERROR
1476 << "SetPIDValues: thermal mode iface invalid "
1477 << path;
James Feist73df0db2019-03-25 15:29:35 -07001478 messages::internalError(self->asyncResp->res);
1479 return;
1480 }
1481 self->currentProfile = *current;
1482 self->supportedProfiles = *supported;
1483 self->profileConnection = owner;
1484 self->profilePath = path;
1485 },
1486 owner, path, "org.freedesktop.DBus.Properties", "GetAll",
1487 thermalModeIface);
1488 },
1489 "xyz.openbmc_project.ObjectMapper",
1490 "/xyz/openbmc_project/object_mapper",
1491 "xyz.openbmc_project.ObjectMapper", "GetSubTree", "/", 0,
1492 std::array<const char*, 1>{thermalModeIface});
1493 }
Ed Tanous24b2fe82022-01-06 12:45:54 -08001494 void pidSetDone()
James Feist73df0db2019-03-25 15:29:35 -07001495 {
1496 if (asyncResp->res.result() != boost::beast::http::status::ok)
1497 {
1498 return;
1499 }
zhanghch058d1b46d2021-04-01 11:18:24 +08001500 std::shared_ptr<bmcweb::AsyncResp> response = asyncResp;
James Feist73df0db2019-03-25 15:29:35 -07001501 if (profile)
1502 {
1503 if (std::find(supportedProfiles.begin(), supportedProfiles.end(),
1504 *profile) == supportedProfiles.end())
1505 {
1506 messages::actionParameterUnknown(response->res, "Profile",
1507 *profile);
1508 return;
1509 }
1510 currentProfile = *profile;
1511 crow::connections::systemBus->async_method_call(
1512 [response](const boost::system::error_code ec) {
1513 if (ec)
1514 {
1515 BMCWEB_LOG_ERROR << "Error patching profile" << ec;
1516 messages::internalError(response->res);
1517 }
1518 },
1519 profileConnection, profilePath,
1520 "org.freedesktop.DBus.Properties", "Set", thermalModeIface,
Ed Tanous168e20c2021-12-13 14:39:53 -08001521 "Current", dbus::utility::DbusVariantType(*profile));
James Feist73df0db2019-03-25 15:29:35 -07001522 }
1523
1524 for (auto& containerPair : configuration)
1525 {
1526 auto& container = containerPair.second;
1527 if (!container)
1528 {
1529 continue;
1530 }
James Feist6ee7f772020-02-06 16:25:27 -08001531 BMCWEB_LOG_DEBUG << *container;
1532
James Feist73df0db2019-03-25 15:29:35 -07001533 std::string& type = containerPair.first;
1534
1535 for (nlohmann::json::iterator it = container->begin();
Manojkiran Eda17a897d2020-09-12 15:31:58 +05301536 it != container->end(); ++it)
James Feist73df0db2019-03-25 15:29:35 -07001537 {
1538 const auto& name = it.key();
James Feist6ee7f772020-02-06 16:25:27 -08001539 BMCWEB_LOG_DEBUG << "looking for " << name;
1540
James Feist73df0db2019-03-25 15:29:35 -07001541 auto pathItr =
1542 std::find_if(managedObj.begin(), managedObj.end(),
1543 [&name](const auto& obj) {
1544 return boost::algorithm::ends_with(
1545 obj.first.str, "/" + name);
1546 });
1547 boost::container::flat_map<std::string,
1548 dbus::utility::DbusVariantType>
1549 output;
1550
1551 output.reserve(16); // The pid interface length
1552
1553 // determines if we're patching entity-manager or
1554 // creating a new object
1555 bool createNewObject = (pathItr == managedObj.end());
James Feist6ee7f772020-02-06 16:25:27 -08001556 BMCWEB_LOG_DEBUG << "Found = " << !createNewObject;
1557
James Feist73df0db2019-03-25 15:29:35 -07001558 std::string iface;
Ed Tanous711ac7a2021-12-20 09:34:41 -08001559 /*
James Feist73df0db2019-03-25 15:29:35 -07001560 if (type == "PidControllers" || type == "FanControllers")
1561 {
1562 iface = pidConfigurationIface;
1563 if (!createNewObject &&
1564 pathItr->second.find(pidConfigurationIface) ==
1565 pathItr->second.end())
1566 {
1567 createNewObject = true;
1568 }
1569 }
1570 else if (type == "FanZones")
1571 {
1572 iface = pidZoneConfigurationIface;
1573 if (!createNewObject &&
1574 pathItr->second.find(pidZoneConfigurationIface) ==
1575 pathItr->second.end())
1576 {
1577
1578 createNewObject = true;
1579 }
1580 }
1581 else if (type == "StepwiseControllers")
1582 {
1583 iface = stepwiseConfigurationIface;
1584 if (!createNewObject &&
1585 pathItr->second.find(stepwiseConfigurationIface) ==
1586 pathItr->second.end())
1587 {
1588 createNewObject = true;
1589 }
Ed Tanous711ac7a2021-12-20 09:34:41 -08001590 }*/
James Feist6ee7f772020-02-06 16:25:27 -08001591
1592 if (createNewObject && it.value() == nullptr)
1593 {
Gunnar Mills4e0453b2020-07-08 14:00:30 -05001594 // can't delete a non-existent object
James Feist6ee7f772020-02-06 16:25:27 -08001595 messages::invalidObject(response->res, name);
1596 continue;
1597 }
1598
1599 std::string path;
1600 if (pathItr != managedObj.end())
1601 {
1602 path = pathItr->first.str;
1603 }
1604
James Feist73df0db2019-03-25 15:29:35 -07001605 BMCWEB_LOG_DEBUG << "Create new = " << createNewObject << "\n";
James Feiste69d9de2020-02-07 12:23:27 -08001606
1607 // arbitrary limit to avoid attacks
1608 constexpr const size_t controllerLimit = 500;
James Feist14b0b8d2020-02-12 11:52:07 -08001609 if (createNewObject && objectCount >= controllerLimit)
James Feiste69d9de2020-02-07 12:23:27 -08001610 {
1611 messages::resourceExhaustion(response->res, type);
1612 continue;
1613 }
1614
James Feist73df0db2019-03-25 15:29:35 -07001615 output["Name"] = boost::replace_all_copy(name, "_", " ");
1616
1617 std::string chassis;
1618 CreatePIDRet ret = createPidInterface(
James Feist6ee7f772020-02-06 16:25:27 -08001619 response, type, it, path, managedObj, createNewObject,
1620 output, chassis, currentProfile);
James Feist73df0db2019-03-25 15:29:35 -07001621 if (ret == CreatePIDRet::fail)
1622 {
1623 return;
1624 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001625 if (ret == CreatePIDRet::del)
James Feist73df0db2019-03-25 15:29:35 -07001626 {
1627 continue;
1628 }
1629
1630 if (!createNewObject)
1631 {
1632 for (const auto& property : output)
1633 {
1634 crow::connections::systemBus->async_method_call(
1635 [response,
1636 propertyName{std::string(property.first)}](
1637 const boost::system::error_code ec) {
1638 if (ec)
1639 {
1640 BMCWEB_LOG_ERROR << "Error patching "
1641 << propertyName << ": "
1642 << ec;
1643 messages::internalError(response->res);
1644 return;
1645 }
1646 messages::success(response->res);
1647 },
James Feist6ee7f772020-02-06 16:25:27 -08001648 "xyz.openbmc_project.EntityManager", path,
James Feist73df0db2019-03-25 15:29:35 -07001649 "org.freedesktop.DBus.Properties", "Set", iface,
1650 property.first, property.second);
1651 }
1652 }
1653 else
1654 {
1655 if (chassis.empty())
1656 {
1657 BMCWEB_LOG_ERROR << "Failed to get chassis from config";
1658 messages::invalidObject(response->res, name);
1659 return;
1660 }
1661
1662 bool foundChassis = false;
1663 for (const auto& obj : managedObj)
1664 {
1665 if (boost::algorithm::ends_with(obj.first.str, chassis))
1666 {
1667 chassis = obj.first.str;
1668 foundChassis = true;
1669 break;
1670 }
1671 }
1672 if (!foundChassis)
1673 {
1674 BMCWEB_LOG_ERROR << "Failed to find chassis on dbus";
1675 messages::resourceMissingAtURI(
1676 response->res, "/redfish/v1/Chassis/" + chassis);
1677 return;
1678 }
1679
1680 crow::connections::systemBus->async_method_call(
1681 [response](const boost::system::error_code ec) {
1682 if (ec)
1683 {
1684 BMCWEB_LOG_ERROR << "Error Adding Pid Object "
1685 << ec;
1686 messages::internalError(response->res);
1687 return;
1688 }
1689 messages::success(response->res);
1690 },
1691 "xyz.openbmc_project.EntityManager", chassis,
1692 "xyz.openbmc_project.AddObject", "AddObject", output);
1693 }
1694 }
1695 }
1696 }
Ed Tanous24b2fe82022-01-06 12:45:54 -08001697
1698 ~SetPIDValues()
1699 {
1700 try
1701 {
1702 pidSetDone();
1703 }
1704 catch (...)
1705 {
1706 BMCWEB_LOG_CRITICAL << "pidSetDone threw exception";
1707 }
1708 }
1709
zhanghch058d1b46d2021-04-01 11:18:24 +08001710 std::shared_ptr<bmcweb::AsyncResp> asyncResp;
James Feist73df0db2019-03-25 15:29:35 -07001711 std::vector<std::pair<std::string, std::optional<nlohmann::json>>>
1712 configuration;
1713 std::optional<std::string> profile;
1714 dbus::utility::ManagedObjectType managedObj;
1715 std::vector<std::string> supportedProfiles;
1716 std::string currentProfile;
1717 std::string profileConnection;
1718 std::string profilePath;
James Feist14b0b8d2020-02-12 11:52:07 -08001719 size_t objectCount = 0;
James Feist73df0db2019-03-25 15:29:35 -07001720};
James Feist83ff9ab2018-08-31 10:18:24 -07001721
SunnySrivastava1984071d8fd2020-10-28 02:20:30 -05001722/**
1723 * @brief Retrieves BMC manager location data over DBus
1724 *
1725 * @param[in] aResp Shared pointer for completing asynchronous calls
1726 * @param[in] connectionName - service name
1727 * @param[in] path - object path
1728 * @return none
1729 */
zhanghch058d1b46d2021-04-01 11:18:24 +08001730inline void getLocation(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
SunnySrivastava1984071d8fd2020-10-28 02:20:30 -05001731 const std::string& connectionName,
1732 const std::string& path)
1733{
1734 BMCWEB_LOG_DEBUG << "Get BMC manager Location data.";
1735
Jonathan Doman1e1e5982021-06-11 09:36:17 -07001736 sdbusplus::asio::getProperty<std::string>(
1737 *crow::connections::systemBus, connectionName, path,
1738 "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode",
SunnySrivastava1984071d8fd2020-10-28 02:20:30 -05001739 [aResp](const boost::system::error_code ec,
Jonathan Doman1e1e5982021-06-11 09:36:17 -07001740 const std::string& property) {
SunnySrivastava1984071d8fd2020-10-28 02:20:30 -05001741 if (ec)
1742 {
1743 BMCWEB_LOG_DEBUG << "DBUS response error for "
1744 "Location";
1745 messages::internalError(aResp->res);
1746 return;
1747 }
1748
SunnySrivastava1984071d8fd2020-10-28 02:20:30 -05001749 aResp->res.jsonValue["Location"]["PartLocation"]["ServiceLabel"] =
Jonathan Doman1e1e5982021-06-11 09:36:17 -07001750 property;
1751 });
SunnySrivastava1984071d8fd2020-10-28 02:20:30 -05001752}
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001753// avoid name collision systems.hpp
1754inline void
1755 managerGetLastResetTime(const std::shared_ptr<bmcweb::AsyncResp>& aResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001756{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001757 BMCWEB_LOG_DEBUG << "Getting Manager Last Reset Time";
Ed Tanous52cc1122020-07-18 13:51:21 -07001758
Jonathan Doman1e1e5982021-06-11 09:36:17 -07001759 sdbusplus::asio::getProperty<uint64_t>(
1760 *crow::connections::systemBus, "xyz.openbmc_project.State.BMC",
1761 "/xyz/openbmc_project/state/bmc0", "xyz.openbmc_project.State.BMC",
1762 "LastRebootTime",
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001763 [aResp](const boost::system::error_code ec,
Jonathan Doman1e1e5982021-06-11 09:36:17 -07001764 const uint64_t lastResetTime) {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001765 if (ec)
James Feist83ff9ab2018-08-31 10:18:24 -07001766 {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001767 BMCWEB_LOG_DEBUG << "D-BUS response error " << ec;
Ed Tanous43b761d2019-02-13 20:10:56 -08001768 return;
1769 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001770
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001771 // LastRebootTime is epoch time, in milliseconds
1772 // https://github.com/openbmc/phosphor-dbus-interfaces/blob/7f9a128eb9296e926422ddc312c148b625890bb6/xyz/openbmc_project/State/BMC.interface.yaml#L19
Jonathan Doman1e1e5982021-06-11 09:36:17 -07001773 uint64_t lastResetTimeStamp = lastResetTime / 1000;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001774
1775 // Convert to ISO 8601 standard
1776 aResp->res.jsonValue["LastResetTime"] =
Nan Zhou1d8782e2021-11-29 22:23:18 -08001777 crow::utility::getDateTimeUint(lastResetTimeStamp);
Jonathan Doman1e1e5982021-06-11 09:36:17 -07001778 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001779}
1780
1781/**
1782 * @brief Set the running firmware image
1783 *
1784 * @param[i,o] aResp - Async response object
1785 * @param[i] runningFirmwareTarget - Image to make the running image
1786 *
1787 * @return void
1788 */
1789inline void
1790 setActiveFirmwareImage(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
1791 const std::string& runningFirmwareTarget)
1792{
1793 // Get the Id from /redfish/v1/UpdateService/FirmwareInventory/<Id>
1794 std::string::size_type idPos = runningFirmwareTarget.rfind('/');
1795 if (idPos == std::string::npos)
1796 {
1797 messages::propertyValueNotInList(aResp->res, runningFirmwareTarget,
1798 "@odata.id");
1799 BMCWEB_LOG_DEBUG << "Can't parse firmware ID!";
1800 return;
1801 }
1802 idPos++;
1803 if (idPos >= runningFirmwareTarget.size())
1804 {
1805 messages::propertyValueNotInList(aResp->res, runningFirmwareTarget,
1806 "@odata.id");
1807 BMCWEB_LOG_DEBUG << "Invalid firmware ID.";
1808 return;
1809 }
1810 std::string firmwareId = runningFirmwareTarget.substr(idPos);
1811
1812 // Make sure the image is valid before setting priority
1813 crow::connections::systemBus->async_method_call(
Ed Tanous711ac7a2021-12-20 09:34:41 -08001814 [aResp, firmwareId,
1815 runningFirmwareTarget](const boost::system::error_code ec,
1816 dbus::utility::ManagedObjectType& subtree) {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001817 if (ec)
Gunnar Mills4bfefa72020-07-30 13:54:29 -05001818 {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001819 BMCWEB_LOG_DEBUG << "D-Bus response error getting objects.";
1820 messages::internalError(aResp->res);
1821 return;
1822 }
1823
1824 if (subtree.size() == 0)
1825 {
1826 BMCWEB_LOG_DEBUG << "Can't find image!";
1827 messages::internalError(aResp->res);
1828 return;
1829 }
1830
1831 bool foundImage = false;
1832 for (auto& object : subtree)
1833 {
1834 const std::string& path =
1835 static_cast<const std::string&>(object.first);
1836 std::size_t idPos2 = path.rfind('/');
1837
1838 if (idPos2 == std::string::npos)
Gunnar Mills4bfefa72020-07-30 13:54:29 -05001839 {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001840 continue;
Gunnar Mills4bfefa72020-07-30 13:54:29 -05001841 }
1842
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001843 idPos2++;
1844 if (idPos2 >= path.size())
Gunnar Mills4bfefa72020-07-30 13:54:29 -05001845 {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001846 continue;
1847 }
1848
1849 if (path.substr(idPos2) == firmwareId)
1850 {
1851 foundImage = true;
1852 break;
Gunnar Mills4bfefa72020-07-30 13:54:29 -05001853 }
1854 }
Santosh Puranikaf5d60582019-03-20 18:16:36 +05301855
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001856 if (!foundImage)
1857 {
1858 messages::propertyValueNotInList(
1859 aResp->res, runningFirmwareTarget, "@odata.id");
1860 BMCWEB_LOG_DEBUG << "Invalid firmware ID.";
1861 return;
1862 }
Gunnar Mills4bf2b032020-06-23 22:28:31 -05001863
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001864 BMCWEB_LOG_DEBUG
1865 << "Setting firmware version " + firmwareId + " to priority 0.";
Gunnar Mills4bf2b032020-06-23 22:28:31 -05001866
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001867 // Only support Immediate
1868 // An addition could be a Redfish Setting like
1869 // ActiveSoftwareImageApplyTime and support OnReset
Santosh Puranikaf5d60582019-03-20 18:16:36 +05301870 crow::connections::systemBus->async_method_call(
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001871 [aResp](const boost::system::error_code ec) {
Santosh Puranikaf5d60582019-03-20 18:16:36 +05301872 if (ec)
1873 {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001874 BMCWEB_LOG_DEBUG << "D-Bus response error setting.";
Santosh Puranikaf5d60582019-03-20 18:16:36 +05301875 messages::internalError(aResp->res);
1876 return;
1877 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001878 doBMCGracefulRestart(aResp);
Santosh Puranikaf5d60582019-03-20 18:16:36 +05301879 },
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001880
1881 "xyz.openbmc_project.Software.BMC.Updater",
1882 "/xyz/openbmc_project/software/" + firmwareId,
Santosh Puranikaf5d60582019-03-20 18:16:36 +05301883 "org.freedesktop.DBus.Properties", "Set",
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001884 "xyz.openbmc_project.Software.RedundancyPriority", "Priority",
Ed Tanous168e20c2021-12-13 14:39:53 -08001885 dbus::utility::DbusVariantType(static_cast<uint8_t>(0)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001886 },
1887 "xyz.openbmc_project.Software.BMC.Updater",
1888 "/xyz/openbmc_project/software", "org.freedesktop.DBus.ObjectManager",
1889 "GetManagedObjects");
1890}
Ed Tanous1abe55e2018-09-05 08:30:59 -07001891
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001892inline void setDateTime(std::shared_ptr<bmcweb::AsyncResp> aResp,
1893 std::string datetime)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001894{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001895 BMCWEB_LOG_DEBUG << "Set date time: " << datetime;
Borawski.Lukasz9c3106852018-02-09 15:24:22 +01001896
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001897 std::stringstream stream(datetime);
1898 // Convert from ISO 8601 to boost local_time
1899 // (BMC only has time in UTC)
1900 boost::posix_time::ptime posixTime;
1901 boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
1902 // Facet gets deleted with the stringsteam
1903 auto ifc = std::make_unique<boost::local_time::local_time_input_facet>(
1904 "%Y-%m-%d %H:%M:%S%F %ZP");
1905 stream.imbue(std::locale(stream.getloc(), ifc.release()));
1906
1907 boost::local_time::local_date_time ldt(boost::local_time::not_a_date_time);
1908
1909 if (stream >> ldt)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001910 {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001911 posixTime = ldt.utc_time();
1912 boost::posix_time::time_duration dur = posixTime - epoch;
1913 uint64_t durMicroSecs = static_cast<uint64_t>(dur.total_microseconds());
1914 crow::connections::systemBus->async_method_call(
1915 [aResp{std::move(aResp)}, datetime{std::move(datetime)}](
1916 const boost::system::error_code ec) {
1917 if (ec)
1918 {
1919 BMCWEB_LOG_DEBUG << "Failed to set elapsed time. "
1920 "DBUS response error "
1921 << ec;
1922 messages::internalError(aResp->res);
1923 return;
1924 }
1925 aResp->res.jsonValue["DateTime"] = datetime;
1926 },
1927 "xyz.openbmc_project.Time.Manager", "/xyz/openbmc_project/time/bmc",
1928 "org.freedesktop.DBus.Properties", "Set",
1929 "xyz.openbmc_project.Time.EpochTime", "Elapsed",
Ed Tanous168e20c2021-12-13 14:39:53 -08001930 dbus::utility::DbusVariantType(durMicroSecs));
Ed Tanous1abe55e2018-09-05 08:30:59 -07001931 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001932 else
1933 {
1934 messages::propertyValueFormatError(aResp->res, datetime, "DateTime");
1935 return;
1936 }
1937}
1938
1939inline void requestRoutesManager(App& app)
1940{
1941 std::string uuid = persistent_data::getConfig().systemUuid;
1942
1943 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/")
Ed Tanoused398212021-06-09 17:05:54 -07001944 .privileges(redfish::privileges::getManager)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001945 .methods(boost::beast::http::verb::get)([uuid](const crow::Request&,
1946 const std::shared_ptr<
1947 bmcweb::AsyncResp>&
1948 asyncResp) {
1949 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Managers/bmc";
1950 asyncResp->res.jsonValue["@odata.type"] =
1951 "#Manager.v1_11_0.Manager";
1952 asyncResp->res.jsonValue["Id"] = "bmc";
1953 asyncResp->res.jsonValue["Name"] = "OpenBmc Manager";
1954 asyncResp->res.jsonValue["Description"] =
1955 "Baseboard Management Controller";
1956 asyncResp->res.jsonValue["PowerState"] = "On";
1957 asyncResp->res.jsonValue["Status"] = {{"State", "Enabled"},
1958 {"Health", "OK"}};
1959 asyncResp->res.jsonValue["ManagerType"] = "BMC";
1960 asyncResp->res.jsonValue["UUID"] = systemd_utils::getUuid();
1961 asyncResp->res.jsonValue["ServiceEntryPointUUID"] = uuid;
1962 asyncResp->res.jsonValue["Model"] =
1963 "OpenBmc"; // TODO(ed), get model
1964
1965 asyncResp->res.jsonValue["LogServices"] = {
1966 {"@odata.id", "/redfish/v1/Managers/bmc/LogServices"}};
1967
1968 asyncResp->res.jsonValue["NetworkProtocol"] = {
1969 {"@odata.id", "/redfish/v1/Managers/bmc/NetworkProtocol"}};
1970
1971 asyncResp->res.jsonValue["EthernetInterfaces"] = {
1972 {"@odata.id", "/redfish/v1/Managers/bmc/EthernetInterfaces"}};
1973
1974#ifdef BMCWEB_ENABLE_VM_NBDPROXY
1975 asyncResp->res.jsonValue["VirtualMedia"] = {
1976 {"@odata.id", "/redfish/v1/Managers/bmc/VirtualMedia"}};
1977#endif // BMCWEB_ENABLE_VM_NBDPROXY
1978
1979 // default oem data
1980 nlohmann::json& oem = asyncResp->res.jsonValue["Oem"];
1981 nlohmann::json& oemOpenbmc = oem["OpenBmc"];
1982 oem["@odata.type"] = "#OemManager.Oem";
1983 oem["@odata.id"] = "/redfish/v1/Managers/bmc#/Oem";
1984 oemOpenbmc["@odata.type"] = "#OemManager.OpenBmc";
1985 oemOpenbmc["@odata.id"] = "/redfish/v1/Managers/bmc#/Oem/OpenBmc";
1986 oemOpenbmc["Certificates"] = {
1987 {"@odata.id",
1988 "/redfish/v1/Managers/bmc/Truststore/Certificates"}};
1989
1990 // Manager.Reset (an action) can be many values, OpenBMC only
1991 // supports BMC reboot.
1992 nlohmann::json& managerReset =
1993 asyncResp->res.jsonValue["Actions"]["#Manager.Reset"];
1994 managerReset["target"] =
1995 "/redfish/v1/Managers/bmc/Actions/Manager.Reset";
1996 managerReset["@Redfish.ActionInfo"] =
1997 "/redfish/v1/Managers/bmc/ResetActionInfo";
1998
1999 // ResetToDefaults (Factory Reset) has values like
2000 // PreserveNetworkAndUsers and PreserveNetwork that aren't supported
2001 // on OpenBMC
2002 nlohmann::json& resetToDefaults =
2003 asyncResp->res.jsonValue["Actions"]["#Manager.ResetToDefaults"];
2004 resetToDefaults["target"] =
2005 "/redfish/v1/Managers/bmc/Actions/Manager.ResetToDefaults";
2006 resetToDefaults["ResetType@Redfish.AllowableValues"] = {"ResetAll"};
2007
Tejas Patil7c8c4052021-06-04 17:43:14 +05302008 std::pair<std::string, std::string> redfishDateTimeOffset =
2009 crow::utility::getDateTimeOffsetNow();
2010
2011 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2012 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2013 redfishDateTimeOffset.second;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002014
Gunnar Mills0e8ac5e2020-11-06 15:33:24 -06002015 // TODO (Gunnar): Remove these one day since moved to ComputerSystem
2016 // Still used by OCP profiles
2017 // https://github.com/opencomputeproject/OCP-Profiles/issues/23
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002018 // Fill in SerialConsole info
2019 asyncResp->res.jsonValue["SerialConsole"]["ServiceEnabled"] = true;
2020 asyncResp->res.jsonValue["SerialConsole"]["MaxConcurrentSessions"] =
2021 15;
2022 asyncResp->res.jsonValue["SerialConsole"]["ConnectTypesSupported"] =
2023 {"IPMI", "SSH"};
2024#ifdef BMCWEB_ENABLE_KVM
2025 // Fill in GraphicalConsole info
2026 asyncResp->res.jsonValue["GraphicalConsole"]["ServiceEnabled"] =
2027 true;
2028 asyncResp->res
2029 .jsonValue["GraphicalConsole"]["MaxConcurrentSessions"] = 4;
2030 asyncResp->res.jsonValue["GraphicalConsole"]
2031 ["ConnectTypesSupported"] = {"KVMIP"};
2032#endif // BMCWEB_ENABLE_KVM
2033
2034 asyncResp->res.jsonValue["Links"]["ManagerForServers@odata.count"] =
2035 1;
2036 asyncResp->res.jsonValue["Links"]["ManagerForServers"] = {
2037 {{"@odata.id", "/redfish/v1/Systems/system"}}};
2038
2039 auto health = std::make_shared<HealthPopulate>(asyncResp);
2040 health->isManagersHealth = true;
2041 health->populate();
2042
2043 fw_util::populateFirmwareInformation(asyncResp, fw_util::bmcPurpose,
2044 "FirmwareVersion", true);
2045
2046 managerGetLastResetTime(asyncResp);
2047
2048 auto pids = std::make_shared<GetPIDValues>(asyncResp);
2049 pids->run();
2050
2051 getMainChassisId(
2052 asyncResp, [](const std::string& chassisId,
2053 const std::shared_ptr<bmcweb::AsyncResp>& aRsp) {
2054 aRsp->res
2055 .jsonValue["Links"]["ManagerForChassis@odata.count"] =
2056 1;
2057 aRsp->res.jsonValue["Links"]["ManagerForChassis"] = {
2058 {{"@odata.id", "/redfish/v1/Chassis/" + chassisId}}};
2059 aRsp->res.jsonValue["Links"]["ManagerInChassis"] = {
2060 {"@odata.id", "/redfish/v1/Chassis/" + chassisId}};
2061 });
2062
2063 static bool started = false;
2064
2065 if (!started)
2066 {
Jonathan Doman1e1e5982021-06-11 09:36:17 -07002067 sdbusplus::asio::getProperty<double>(
2068 *crow::connections::systemBus, "org.freedesktop.systemd1",
2069 "/org/freedesktop/systemd1",
2070 "org.freedesktop.systemd1.Manager", "Progress",
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002071 [asyncResp](const boost::system::error_code ec,
Jonathan Doman1e1e5982021-06-11 09:36:17 -07002072 const double& val) {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002073 if (ec)
2074 {
2075 BMCWEB_LOG_ERROR << "Error while getting progress";
2076 messages::internalError(asyncResp->res);
2077 return;
2078 }
Jonathan Doman1e1e5982021-06-11 09:36:17 -07002079 if (val < 1.0)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002080 {
2081 asyncResp->res.jsonValue["Status"]["State"] =
2082 "Starting";
2083 started = true;
2084 }
Jonathan Doman1e1e5982021-06-11 09:36:17 -07002085 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002086 }
2087
2088 crow::connections::systemBus->async_method_call(
2089 [asyncResp](
2090 const boost::system::error_code ec,
2091 const std::vector<
2092 std::pair<std::string,
2093 std::vector<std::pair<
2094 std::string, std::vector<std::string>>>>>&
2095 subtree) {
2096 if (ec)
2097 {
2098 BMCWEB_LOG_DEBUG
2099 << "D-Bus response error on GetSubTree " << ec;
2100 return;
2101 }
2102 if (subtree.size() == 0)
2103 {
2104 BMCWEB_LOG_DEBUG << "Can't find bmc D-Bus object!";
2105 return;
2106 }
2107 // Assume only 1 bmc D-Bus object
2108 // Throw an error if there is more than 1
2109 if (subtree.size() > 1)
2110 {
2111 BMCWEB_LOG_DEBUG
2112 << "Found more than 1 bmc D-Bus object!";
2113 messages::internalError(asyncResp->res);
2114 return;
2115 }
2116
2117 if (subtree[0].first.empty() ||
2118 subtree[0].second.size() != 1)
2119 {
2120 BMCWEB_LOG_DEBUG << "Error getting bmc D-Bus object!";
2121 messages::internalError(asyncResp->res);
2122 return;
2123 }
2124
2125 const std::string& path = subtree[0].first;
2126 const std::string& connectionName =
2127 subtree[0].second[0].first;
2128
2129 for (const auto& interfaceName :
2130 subtree[0].second[0].second)
2131 {
2132 if (interfaceName ==
2133 "xyz.openbmc_project.Inventory.Decorator.Asset")
2134 {
2135 crow::connections::systemBus->async_method_call(
2136 [asyncResp](
2137 const boost::system::error_code ec,
Ed Tanous168e20c2021-12-13 14:39:53 -08002138 const std::vector<std::pair<
2139 std::string,
2140 dbus::utility::DbusVariantType>>&
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002141 propertiesList) {
2142 if (ec)
2143 {
2144 BMCWEB_LOG_DEBUG
2145 << "Can't get bmc asset!";
2146 return;
2147 }
2148 for (const std::pair<
2149 std::string,
Ed Tanous168e20c2021-12-13 14:39:53 -08002150 dbus::utility::DbusVariantType>&
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002151 property : propertiesList)
2152 {
2153 const std::string& propertyName =
2154 property.first;
2155
2156 if ((propertyName == "PartNumber") ||
2157 (propertyName == "SerialNumber") ||
2158 (propertyName == "Manufacturer") ||
2159 (propertyName == "Model") ||
2160 (propertyName == "SparePartNumber"))
2161 {
2162 const std::string* value =
2163 std::get_if<std::string>(
2164 &property.second);
2165 if (value == nullptr)
2166 {
2167 // illegal property
2168 messages::internalError(
2169 asyncResp->res);
2170 return;
2171 }
2172 asyncResp->res
2173 .jsonValue[propertyName] =
2174 *value;
2175 }
2176 }
2177 },
2178 connectionName, path,
2179 "org.freedesktop.DBus.Properties", "GetAll",
George Liu0fda0f12021-11-16 10:06:17 +08002180 "xyz.openbmc_project.Inventory.Decorator.Asset");
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002181 }
George Liu0fda0f12021-11-16 10:06:17 +08002182 else if (
2183 interfaceName ==
2184 "xyz.openbmc_project.Inventory.Decorator.LocationCode")
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002185 {
2186 getLocation(asyncResp, connectionName, path);
2187 }
2188 }
2189 },
2190 "xyz.openbmc_project.ObjectMapper",
2191 "/xyz/openbmc_project/object_mapper",
2192 "xyz.openbmc_project.ObjectMapper", "GetSubTree",
2193 "/xyz/openbmc_project/inventory", int32_t(0),
2194 std::array<const char*, 1>{
2195 "xyz.openbmc_project.Inventory.Item.Bmc"});
2196 });
2197
2198 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/")
Ed Tanoused398212021-06-09 17:05:54 -07002199 .privileges(redfish::privileges::patchManager)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002200 .methods(
2201 boost::beast::http::verb::
2202 patch)([](const crow::Request& req,
2203 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
2204 std::optional<nlohmann::json> oem;
2205 std::optional<nlohmann::json> links;
2206 std::optional<std::string> datetime;
2207
2208 if (!json_util::readJson(req, asyncResp->res, "Oem", oem,
2209 "DateTime", datetime, "Links", links))
2210 {
2211 return;
2212 }
2213
2214 if (oem)
2215 {
2216 std::optional<nlohmann::json> openbmc;
2217 if (!redfish::json_util::readJson(*oem, asyncResp->res,
2218 "OpenBmc", openbmc))
2219 {
2220 BMCWEB_LOG_ERROR
2221 << "Illegal Property "
2222 << oem->dump(2, ' ', true,
2223 nlohmann::json::error_handler_t::replace);
2224 return;
2225 }
2226 if (openbmc)
2227 {
2228 std::optional<nlohmann::json> fan;
2229 if (!redfish::json_util::readJson(*openbmc, asyncResp->res,
2230 "Fan", fan))
2231 {
2232 BMCWEB_LOG_ERROR
2233 << "Illegal Property "
2234 << openbmc->dump(
2235 2, ' ', true,
2236 nlohmann::json::error_handler_t::replace);
2237 return;
2238 }
2239 if (fan)
2240 {
2241 auto pid =
2242 std::make_shared<SetPIDValues>(asyncResp, *fan);
2243 pid->run();
2244 }
2245 }
2246 }
2247 if (links)
2248 {
2249 std::optional<nlohmann::json> activeSoftwareImage;
2250 if (!redfish::json_util::readJson(*links, asyncResp->res,
2251 "ActiveSoftwareImage",
2252 activeSoftwareImage))
2253 {
2254 return;
2255 }
2256 if (activeSoftwareImage)
2257 {
2258 std::optional<std::string> odataId;
2259 if (!json_util::readJson(*activeSoftwareImage,
2260 asyncResp->res, "@odata.id",
2261 odataId))
2262 {
2263 return;
2264 }
2265
2266 if (odataId)
2267 {
2268 setActiveFirmwareImage(asyncResp, *odataId);
2269 }
2270 }
2271 }
2272 if (datetime)
2273 {
2274 setDateTime(asyncResp, std::move(*datetime));
2275 }
2276 });
2277}
2278
2279inline void requestRoutesManagerCollection(App& app)
2280{
2281 BMCWEB_ROUTE(app, "/redfish/v1/Managers/")
Ed Tanoused398212021-06-09 17:05:54 -07002282 .privileges(redfish::privileges::getManagerCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002283 .methods(boost::beast::http::verb::get)(
2284 [](const crow::Request&,
2285 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
2286 // Collections don't include the static data added by SubRoute
2287 // because it has a duplicate entry for members
2288 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Managers";
2289 asyncResp->res.jsonValue["@odata.type"] =
2290 "#ManagerCollection.ManagerCollection";
2291 asyncResp->res.jsonValue["Name"] = "Manager Collection";
2292 asyncResp->res.jsonValue["Members@odata.count"] = 1;
2293 asyncResp->res.jsonValue["Members"] = {
2294 {{"@odata.id", "/redfish/v1/Managers/bmc"}}};
2295 });
2296}
Ed Tanous1abe55e2018-09-05 08:30:59 -07002297} // namespace redfish