xref: /openbmc/bmcweb/features/redfish/lib/hypervisor_system.hpp (revision 1476687deb1697d865b20458a0097c9ab5fd44e2)
1d5afb2caSAndrew Geissler #pragma once
2d5afb2caSAndrew Geissler 
37e860f15SJohn Edward Broadbent #include <app.hpp>
4d5afb2caSAndrew Geissler #include <boost/container/flat_set.hpp>
5d5afb2caSAndrew Geissler #include <dbus_singleton.hpp>
6168e20c1SEd Tanous #include <dbus_utility.hpp>
7d5afb2caSAndrew Geissler #include <error_messages.hpp>
845ca1b86SEd Tanous #include <query.hpp>
9ed398213SEd Tanous #include <registries/privilege_registry.hpp>
101e1e598dSJonathan Doman #include <sdbusplus/asio/property.hpp>
11d5afb2caSAndrew Geissler #include <utils/json_utils.hpp>
12d5afb2caSAndrew Geissler 
13d5afb2caSAndrew Geissler #include <optional>
14d5afb2caSAndrew Geissler #include <utility>
15d5afb2caSAndrew Geissler 
16b8983957SEd Tanous // TODO(ed) requestRoutesHypervisorSystems seems to have copy-pasted a
17b8983957SEd Tanous // lot of code, and has a number of methods that have name conflicts with the
18b8983957SEd Tanous // normal ethernet internfaces in ethernet.hpp.  For the moment, we'll put
19b8983957SEd Tanous // hypervisor in a namespace to isolate it, but these methods eventually need
20b8983957SEd Tanous // deduplicated
21b8983957SEd Tanous namespace redfish::hypervisor
22d5afb2caSAndrew Geissler {
23d5afb2caSAndrew Geissler 
24d5afb2caSAndrew Geissler /**
25cc0bb6f2SAndrew Geissler  * @brief Retrieves hypervisor state properties over dbus
26cc0bb6f2SAndrew Geissler  *
27cc0bb6f2SAndrew Geissler  * The hypervisor state object is optional so this function will only set the
28cc0bb6f2SAndrew Geissler  * state variables if the object is found
29cc0bb6f2SAndrew Geissler  *
30cc0bb6f2SAndrew Geissler  * @param[in] aResp     Shared pointer for completing asynchronous calls.
31cc0bb6f2SAndrew Geissler  *
32cc0bb6f2SAndrew Geissler  * @return None.
33cc0bb6f2SAndrew Geissler  */
348d1b46d7Szhanghch05 inline void getHypervisorState(const std::shared_ptr<bmcweb::AsyncResp>& aResp)
35cc0bb6f2SAndrew Geissler {
36cc0bb6f2SAndrew Geissler     BMCWEB_LOG_DEBUG << "Get hypervisor state information.";
371e1e598dSJonathan Doman     sdbusplus::asio::getProperty<std::string>(
381e1e598dSJonathan Doman         *crow::connections::systemBus, "xyz.openbmc_project.State.Hypervisor",
391e1e598dSJonathan Doman         "/xyz/openbmc_project/state/hypervisor0",
401e1e598dSJonathan Doman         "xyz.openbmc_project.State.Host", "CurrentHostState",
41cc0bb6f2SAndrew Geissler         [aResp](const boost::system::error_code ec,
421e1e598dSJonathan Doman                 const std::string& hostState) {
43cc0bb6f2SAndrew Geissler             if (ec)
44cc0bb6f2SAndrew Geissler             {
45cc0bb6f2SAndrew Geissler                 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
46cc0bb6f2SAndrew Geissler                 // This is an optional D-Bus object so just return if
47cc0bb6f2SAndrew Geissler                 // error occurs
48cc0bb6f2SAndrew Geissler                 return;
49cc0bb6f2SAndrew Geissler             }
50cc0bb6f2SAndrew Geissler 
511e1e598dSJonathan Doman             BMCWEB_LOG_DEBUG << "Hypervisor state: " << hostState;
52cc0bb6f2SAndrew Geissler             // Verify Host State
531e1e598dSJonathan Doman             if (hostState == "xyz.openbmc_project.State.Host.HostState.Running")
54cc0bb6f2SAndrew Geissler             {
55cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["PowerState"] = "On";
56cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["Status"]["State"] = "Enabled";
57cc0bb6f2SAndrew Geissler             }
581e1e598dSJonathan Doman             else if (hostState == "xyz.openbmc_project.State.Host.HostState."
591e1e598dSJonathan Doman                                   "Quiesced")
60cc0bb6f2SAndrew Geissler             {
61cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["PowerState"] = "On";
62cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["Status"]["State"] = "Quiesced";
63cc0bb6f2SAndrew Geissler             }
641e1e598dSJonathan Doman             else if (hostState == "xyz.openbmc_project.State.Host.HostState."
651e1e598dSJonathan Doman                                   "Standby")
66cc0bb6f2SAndrew Geissler             {
67cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["PowerState"] = "On";
68cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["Status"]["State"] = "StandbyOffline";
69cc0bb6f2SAndrew Geissler             }
701e1e598dSJonathan Doman             else if (hostState == "xyz.openbmc_project.State.Host.HostState."
711e1e598dSJonathan Doman                                   "TransitioningToRunning")
72cc0bb6f2SAndrew Geissler             {
73cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["PowerState"] = "PoweringOn";
74cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["Status"]["State"] = "Starting";
75cc0bb6f2SAndrew Geissler             }
761e1e598dSJonathan Doman             else if (hostState == "xyz.openbmc_project.State.Host.HostState."
771e1e598dSJonathan Doman                                   "TransitioningToOff")
78cc0bb6f2SAndrew Geissler             {
79cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["PowerState"] = "PoweringOff";
80cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["Status"]["State"] = "Enabled";
81cc0bb6f2SAndrew Geissler             }
821e1e598dSJonathan Doman             else if (hostState ==
831e1e598dSJonathan Doman                      "xyz.openbmc_project.State.Host.HostState.Off")
84cc0bb6f2SAndrew Geissler             {
85cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["PowerState"] = "Off";
86cc0bb6f2SAndrew Geissler                 aResp->res.jsonValue["Status"]["State"] = "Disabled";
87cc0bb6f2SAndrew Geissler             }
88cc0bb6f2SAndrew Geissler             else
89cc0bb6f2SAndrew Geissler             {
90cc0bb6f2SAndrew Geissler                 messages::internalError(aResp->res);
91cc0bb6f2SAndrew Geissler                 return;
92cc0bb6f2SAndrew Geissler             }
931e1e598dSJonathan Doman         });
94cc0bb6f2SAndrew Geissler }
95cc0bb6f2SAndrew Geissler 
96cc0bb6f2SAndrew Geissler /**
974fbaf64aSAndrew Geissler  * @brief Populate Actions if any are valid for hypervisor object
984fbaf64aSAndrew Geissler  *
994fbaf64aSAndrew Geissler  * The hypervisor state object is optional so this function will only set the
1004fbaf64aSAndrew Geissler  * Action if the object is found
1014fbaf64aSAndrew Geissler  *
1024fbaf64aSAndrew Geissler  * @param[in] aResp     Shared pointer for completing asynchronous calls.
1034fbaf64aSAndrew Geissler  *
1044fbaf64aSAndrew Geissler  * @return None.
1054fbaf64aSAndrew Geissler  */
1068d1b46d7Szhanghch05 inline void
1078d1b46d7Szhanghch05     getHypervisorActions(const std::shared_ptr<bmcweb::AsyncResp>& aResp)
1084fbaf64aSAndrew Geissler {
1094fbaf64aSAndrew Geissler     BMCWEB_LOG_DEBUG << "Get hypervisor actions.";
1104fbaf64aSAndrew Geissler     crow::connections::systemBus->async_method_call(
1114fbaf64aSAndrew Geissler         [aResp](
1124fbaf64aSAndrew Geissler             const boost::system::error_code ec,
1134fbaf64aSAndrew Geissler             const std::vector<std::pair<std::string, std::vector<std::string>>>&
1144fbaf64aSAndrew Geissler                 objInfo) {
1154fbaf64aSAndrew Geissler             if (ec)
1164fbaf64aSAndrew Geissler             {
1174fbaf64aSAndrew Geissler                 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1184fbaf64aSAndrew Geissler                 // This is an optional D-Bus object so just return if
1194fbaf64aSAndrew Geissler                 // error occurs
1204fbaf64aSAndrew Geissler                 return;
1214fbaf64aSAndrew Geissler             }
1224fbaf64aSAndrew Geissler 
12326f6976fSEd Tanous             if (objInfo.empty())
1244fbaf64aSAndrew Geissler             {
1254fbaf64aSAndrew Geissler                 // As noted above, this is an optional interface so just return
1264fbaf64aSAndrew Geissler                 // if there is no instance found
1274fbaf64aSAndrew Geissler                 return;
1284fbaf64aSAndrew Geissler             }
1294fbaf64aSAndrew Geissler 
1304fbaf64aSAndrew Geissler             if (objInfo.size() > 1)
1314fbaf64aSAndrew Geissler             {
1324fbaf64aSAndrew Geissler                 // More then one hypervisor object is not supported and is an
1334fbaf64aSAndrew Geissler                 // error
1344fbaf64aSAndrew Geissler                 messages::internalError(aResp->res);
1354fbaf64aSAndrew Geissler                 return;
1364fbaf64aSAndrew Geissler             }
1374fbaf64aSAndrew Geissler 
1384fbaf64aSAndrew Geissler             // Object present so system support limited ComputerSystem Action
1394fbaf64aSAndrew Geissler             aResp->res.jsonValue["Actions"]["#ComputerSystem.Reset"] = {
1404fbaf64aSAndrew Geissler                 {"target",
1414fbaf64aSAndrew Geissler                  "/redfish/v1/Systems/hypervisor/Actions/ComputerSystem.Reset"},
1424fbaf64aSAndrew Geissler                 {"@Redfish.ActionInfo",
1434fbaf64aSAndrew Geissler                  "/redfish/v1/Systems/hypervisor/ResetActionInfo"}};
1444fbaf64aSAndrew Geissler         },
1454fbaf64aSAndrew Geissler         "xyz.openbmc_project.ObjectMapper",
1464fbaf64aSAndrew Geissler         "/xyz/openbmc_project/object_mapper",
1474fbaf64aSAndrew Geissler         "xyz.openbmc_project.ObjectMapper", "GetObject",
1484fbaf64aSAndrew Geissler         "/xyz/openbmc_project/state/hypervisor0",
1494fbaf64aSAndrew Geissler         std::array<const char*, 1>{"xyz.openbmc_project.State.Host"});
1504fbaf64aSAndrew Geissler }
1514fbaf64aSAndrew Geissler 
152d5afb2caSAndrew Geissler inline bool extractHypervisorInterfaceData(
153711ac7a9SEd Tanous     const std::string& ethIfaceId,
154711ac7a9SEd Tanous     const dbus::utility::ManagedObjectType& dbusData,
155d5afb2caSAndrew Geissler     EthernetInterfaceData& ethData,
156d5afb2caSAndrew Geissler     boost::container::flat_set<IPv4AddressData>& ipv4Config)
157d5afb2caSAndrew Geissler {
158d5afb2caSAndrew Geissler     bool idFound = false;
159d5afb2caSAndrew Geissler     for (const auto& objpath : dbusData)
160d5afb2caSAndrew Geissler     {
161d5afb2caSAndrew Geissler         for (const auto& ifacePair : objpath.second)
162d5afb2caSAndrew Geissler         {
163d5afb2caSAndrew Geissler             if (objpath.first ==
164d5afb2caSAndrew Geissler                 "/xyz/openbmc_project/network/hypervisor/" + ethIfaceId)
165d5afb2caSAndrew Geissler             {
166d5afb2caSAndrew Geissler                 idFound = true;
167d5afb2caSAndrew Geissler                 if (ifacePair.first == "xyz.openbmc_project.Network.MACAddress")
168d5afb2caSAndrew Geissler                 {
169d5afb2caSAndrew Geissler                     for (const auto& propertyPair : ifacePair.second)
170d5afb2caSAndrew Geissler                     {
171d5afb2caSAndrew Geissler                         if (propertyPair.first == "MACAddress")
172d5afb2caSAndrew Geissler                         {
173d5afb2caSAndrew Geissler                             const std::string* mac =
174d5afb2caSAndrew Geissler                                 std::get_if<std::string>(&propertyPair.second);
175d5afb2caSAndrew Geissler                             if (mac != nullptr)
176d5afb2caSAndrew Geissler                             {
17782695a5bSJiaqing Zhao                                 ethData.macAddress = *mac;
178d5afb2caSAndrew Geissler                             }
179d5afb2caSAndrew Geissler                         }
180d5afb2caSAndrew Geissler                     }
181d5afb2caSAndrew Geissler                 }
182d5afb2caSAndrew Geissler                 else if (ifacePair.first ==
183d5afb2caSAndrew Geissler                          "xyz.openbmc_project.Network.EthernetInterface")
184d5afb2caSAndrew Geissler                 {
185d5afb2caSAndrew Geissler                     for (const auto& propertyPair : ifacePair.second)
186d5afb2caSAndrew Geissler                     {
187d5afb2caSAndrew Geissler                         if (propertyPair.first == "DHCPEnabled")
188d5afb2caSAndrew Geissler                         {
189d5afb2caSAndrew Geissler                             const std::string* dhcp =
190d5afb2caSAndrew Geissler                                 std::get_if<std::string>(&propertyPair.second);
191d5afb2caSAndrew Geissler                             if (dhcp != nullptr)
192d5afb2caSAndrew Geissler                             {
19382695a5bSJiaqing Zhao                                 ethData.dhcpEnabled = *dhcp;
194d5afb2caSAndrew Geissler                                 break; // Interested on only "DHCPEnabled".
195d5afb2caSAndrew Geissler                                        // Stop parsing since we got the
196d5afb2caSAndrew Geissler                                        // "DHCPEnabled" value.
197d5afb2caSAndrew Geissler                             }
198d5afb2caSAndrew Geissler                         }
199d5afb2caSAndrew Geissler                     }
200d5afb2caSAndrew Geissler                 }
201d5afb2caSAndrew Geissler             }
202d5afb2caSAndrew Geissler             if (objpath.first == "/xyz/openbmc_project/network/hypervisor/" +
203d5afb2caSAndrew Geissler                                      ethIfaceId + "/ipv4/addr0")
204d5afb2caSAndrew Geissler             {
205d5afb2caSAndrew Geissler                 std::pair<boost::container::flat_set<IPv4AddressData>::iterator,
206d5afb2caSAndrew Geissler                           bool>
207d5afb2caSAndrew Geissler                     it = ipv4Config.insert(IPv4AddressData{});
208d5afb2caSAndrew Geissler                 IPv4AddressData& ipv4Address = *it.first;
209d5afb2caSAndrew Geissler                 if (ifacePair.first == "xyz.openbmc_project.Object.Enable")
210d5afb2caSAndrew Geissler                 {
2119eb808c1SEd Tanous                     for (const auto& property : ifacePair.second)
212d5afb2caSAndrew Geissler                     {
213d5afb2caSAndrew Geissler                         if (property.first == "Enabled")
214d5afb2caSAndrew Geissler                         {
215d5afb2caSAndrew Geissler                             const bool* intfEnable =
216d5afb2caSAndrew Geissler                                 std::get_if<bool>(&property.second);
217d5afb2caSAndrew Geissler                             if (intfEnable != nullptr)
218d5afb2caSAndrew Geissler                             {
219d5afb2caSAndrew Geissler                                 ipv4Address.isActive = *intfEnable;
220d5afb2caSAndrew Geissler                                 break;
221d5afb2caSAndrew Geissler                             }
222d5afb2caSAndrew Geissler                         }
223d5afb2caSAndrew Geissler                     }
224d5afb2caSAndrew Geissler                 }
225d5afb2caSAndrew Geissler                 if (ifacePair.first == "xyz.openbmc_project.Network.IP")
226d5afb2caSAndrew Geissler                 {
2279eb808c1SEd Tanous                     for (const auto& property : ifacePair.second)
228d5afb2caSAndrew Geissler                     {
229d5afb2caSAndrew Geissler                         if (property.first == "Address")
230d5afb2caSAndrew Geissler                         {
231d5afb2caSAndrew Geissler                             const std::string* address =
232d5afb2caSAndrew Geissler                                 std::get_if<std::string>(&property.second);
233d5afb2caSAndrew Geissler                             if (address != nullptr)
234d5afb2caSAndrew Geissler                             {
235d5afb2caSAndrew Geissler                                 ipv4Address.address = *address;
236d5afb2caSAndrew Geissler                             }
237d5afb2caSAndrew Geissler                         }
238d5afb2caSAndrew Geissler                         else if (property.first == "Origin")
239d5afb2caSAndrew Geissler                         {
240d5afb2caSAndrew Geissler                             const std::string* origin =
241d5afb2caSAndrew Geissler                                 std::get_if<std::string>(&property.second);
242d5afb2caSAndrew Geissler                             if (origin != nullptr)
243d5afb2caSAndrew Geissler                             {
244d5afb2caSAndrew Geissler                                 ipv4Address.origin =
245d5afb2caSAndrew Geissler                                     translateAddressOriginDbusToRedfish(*origin,
246d5afb2caSAndrew Geissler                                                                         true);
247d5afb2caSAndrew Geissler                             }
248d5afb2caSAndrew Geissler                         }
249d5afb2caSAndrew Geissler                         else if (property.first == "PrefixLength")
250d5afb2caSAndrew Geissler                         {
251d5afb2caSAndrew Geissler                             const uint8_t* mask =
252d5afb2caSAndrew Geissler                                 std::get_if<uint8_t>(&property.second);
253d5afb2caSAndrew Geissler                             if (mask != nullptr)
254d5afb2caSAndrew Geissler                             {
255d5afb2caSAndrew Geissler                                 // convert it to the string
256d5afb2caSAndrew Geissler                                 ipv4Address.netmask = getNetmask(*mask);
257d5afb2caSAndrew Geissler                             }
258d5afb2caSAndrew Geissler                         }
259889ff694SAsmitha Karunanithi                         else if (property.first == "Type" ||
260889ff694SAsmitha Karunanithi                                  property.first == "Gateway")
261889ff694SAsmitha Karunanithi                         {
262889ff694SAsmitha Karunanithi                             // Type & Gateway is not used
263889ff694SAsmitha Karunanithi                             continue;
264889ff694SAsmitha Karunanithi                         }
265d5afb2caSAndrew Geissler                         else
266d5afb2caSAndrew Geissler                         {
267d5afb2caSAndrew Geissler                             BMCWEB_LOG_ERROR
268d5afb2caSAndrew Geissler                                 << "Got extra property: " << property.first
269d5afb2caSAndrew Geissler                                 << " on the " << objpath.first.str << " object";
270d5afb2caSAndrew Geissler                         }
271d5afb2caSAndrew Geissler                     }
272d5afb2caSAndrew Geissler                 }
273d5afb2caSAndrew Geissler             }
274d5afb2caSAndrew Geissler             if (objpath.first == "/xyz/openbmc_project/network/hypervisor")
275d5afb2caSAndrew Geissler             {
276d5afb2caSAndrew Geissler                 // System configuration shows up in the global namespace, so no
277d5afb2caSAndrew Geissler                 // need to check eth number
278d5afb2caSAndrew Geissler                 if (ifacePair.first ==
279d5afb2caSAndrew Geissler                     "xyz.openbmc_project.Network.SystemConfiguration")
280d5afb2caSAndrew Geissler                 {
281d5afb2caSAndrew Geissler                     for (const auto& propertyPair : ifacePair.second)
282d5afb2caSAndrew Geissler                     {
283d5afb2caSAndrew Geissler                         if (propertyPair.first == "HostName")
284d5afb2caSAndrew Geissler                         {
285d5afb2caSAndrew Geissler                             const std::string* hostName =
286d5afb2caSAndrew Geissler                                 std::get_if<std::string>(&propertyPair.second);
287d5afb2caSAndrew Geissler                             if (hostName != nullptr)
288d5afb2caSAndrew Geissler                             {
28982695a5bSJiaqing Zhao                                 ethData.hostName = *hostName;
290d5afb2caSAndrew Geissler                             }
291d5afb2caSAndrew Geissler                         }
292d5afb2caSAndrew Geissler                         else if (propertyPair.first == "DefaultGateway")
293d5afb2caSAndrew Geissler                         {
294d5afb2caSAndrew Geissler                             const std::string* defaultGateway =
295d5afb2caSAndrew Geissler                                 std::get_if<std::string>(&propertyPair.second);
296d5afb2caSAndrew Geissler                             if (defaultGateway != nullptr)
297d5afb2caSAndrew Geissler                             {
29882695a5bSJiaqing Zhao                                 ethData.defaultGateway = *defaultGateway;
299d5afb2caSAndrew Geissler                             }
300d5afb2caSAndrew Geissler                         }
301d5afb2caSAndrew Geissler                     }
302d5afb2caSAndrew Geissler                 }
303d5afb2caSAndrew Geissler             }
304d5afb2caSAndrew Geissler         }
305d5afb2caSAndrew Geissler     }
306d5afb2caSAndrew Geissler     return idFound;
307d5afb2caSAndrew Geissler }
308d5afb2caSAndrew Geissler /**
309d5afb2caSAndrew Geissler  * Function that retrieves all properties for given Hypervisor Ethernet
310d5afb2caSAndrew Geissler  * Interface Object from Settings Manager
311d5afb2caSAndrew Geissler  * @param ethIfaceId Hypervisor ethernet interface id to query on DBus
312d5afb2caSAndrew Geissler  * @param callback a function that shall be called to convert Dbus output
313d5afb2caSAndrew Geissler  * into JSON
314d5afb2caSAndrew Geissler  */
315d5afb2caSAndrew Geissler template <typename CallbackFunc>
316d5afb2caSAndrew Geissler void getHypervisorIfaceData(const std::string& ethIfaceId,
317d5afb2caSAndrew Geissler                             CallbackFunc&& callback)
318d5afb2caSAndrew Geissler {
319d5afb2caSAndrew Geissler     crow::connections::systemBus->async_method_call(
320f94c4ecfSEd Tanous         [ethIfaceId{std::string{ethIfaceId}},
321f94c4ecfSEd Tanous          callback{std::forward<CallbackFunc>(callback)}](
322711ac7a9SEd Tanous             const boost::system::error_code error,
323711ac7a9SEd Tanous             const dbus::utility::ManagedObjectType& resp) {
324d5afb2caSAndrew Geissler             EthernetInterfaceData ethData{};
325d5afb2caSAndrew Geissler             boost::container::flat_set<IPv4AddressData> ipv4Data;
326d5afb2caSAndrew Geissler             if (error)
327d5afb2caSAndrew Geissler             {
328d5afb2caSAndrew Geissler                 callback(false, ethData, ipv4Data);
329d5afb2caSAndrew Geissler                 return;
330d5afb2caSAndrew Geissler             }
331d5afb2caSAndrew Geissler 
332d5afb2caSAndrew Geissler             bool found = extractHypervisorInterfaceData(ethIfaceId, resp,
333d5afb2caSAndrew Geissler                                                         ethData, ipv4Data);
334d5afb2caSAndrew Geissler             if (!found)
335d5afb2caSAndrew Geissler             {
336d5afb2caSAndrew Geissler                 BMCWEB_LOG_INFO << "Hypervisor Interface not found";
337d5afb2caSAndrew Geissler             }
338d5afb2caSAndrew Geissler             callback(found, ethData, ipv4Data);
339d5afb2caSAndrew Geissler         },
340d5afb2caSAndrew Geissler         "xyz.openbmc_project.Settings", "/",
341d5afb2caSAndrew Geissler         "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
342d5afb2caSAndrew Geissler }
343d5afb2caSAndrew Geissler 
344d5afb2caSAndrew Geissler /**
345d5afb2caSAndrew Geissler  * @brief Sets the Hypervisor Interface IPAddress DBUS
346d5afb2caSAndrew Geissler  *
347d5afb2caSAndrew Geissler  * @param[in] aResp          Shared pointer for generating response message.
348d5afb2caSAndrew Geissler  * @param[in] ipv4Address    Address from the incoming request
349d5afb2caSAndrew Geissler  * @param[in] ethIfaceId     Hypervisor Interface Id
350d5afb2caSAndrew Geissler  *
351d5afb2caSAndrew Geissler  * @return None.
352d5afb2caSAndrew Geissler  */
3538d1b46d7Szhanghch05 inline void
3548d1b46d7Szhanghch05     setHypervisorIPv4Address(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
355d5afb2caSAndrew Geissler                              const std::string& ethIfaceId,
356d5afb2caSAndrew Geissler                              const std::string& ipv4Address)
357d5afb2caSAndrew Geissler {
358d5afb2caSAndrew Geissler     BMCWEB_LOG_DEBUG << "Setting the Hypervisor IPaddress : " << ipv4Address
359d5afb2caSAndrew Geissler                      << " on Iface: " << ethIfaceId;
360d5afb2caSAndrew Geissler     crow::connections::systemBus->async_method_call(
361d5afb2caSAndrew Geissler         [aResp](const boost::system::error_code ec) {
362d5afb2caSAndrew Geissler             if (ec)
363d5afb2caSAndrew Geissler             {
364d5afb2caSAndrew Geissler                 BMCWEB_LOG_ERROR << "DBUS response error " << ec;
365d5afb2caSAndrew Geissler                 return;
366d5afb2caSAndrew Geissler             }
367d5afb2caSAndrew Geissler             BMCWEB_LOG_DEBUG << "Hypervisor IPaddress is Set";
368d5afb2caSAndrew Geissler         },
369d5afb2caSAndrew Geissler         "xyz.openbmc_project.Settings",
370d5afb2caSAndrew Geissler         "/xyz/openbmc_project/network/hypervisor/" + ethIfaceId + "/ipv4/addr0",
371d5afb2caSAndrew Geissler         "org.freedesktop.DBus.Properties", "Set",
372d5afb2caSAndrew Geissler         "xyz.openbmc_project.Network.IP", "Address",
373168e20c1SEd Tanous         dbus::utility::DbusVariantType(ipv4Address));
374d5afb2caSAndrew Geissler }
375d5afb2caSAndrew Geissler 
376d5afb2caSAndrew Geissler /**
377d5afb2caSAndrew Geissler  * @brief Sets the Hypervisor Interface SubnetMask DBUS
378d5afb2caSAndrew Geissler  *
379d5afb2caSAndrew Geissler  * @param[in] aResp     Shared pointer for generating response message.
380d5afb2caSAndrew Geissler  * @param[in] subnet    SubnetMask from the incoming request
381d5afb2caSAndrew Geissler  * @param[in] ethIfaceId Hypervisor Interface Id
382d5afb2caSAndrew Geissler  *
383d5afb2caSAndrew Geissler  * @return None.
384d5afb2caSAndrew Geissler  */
3858d1b46d7Szhanghch05 inline void
3868d1b46d7Szhanghch05     setHypervisorIPv4Subnet(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
3878d1b46d7Szhanghch05                             const std::string& ethIfaceId, const uint8_t subnet)
388d5afb2caSAndrew Geissler {
389d5afb2caSAndrew Geissler     BMCWEB_LOG_DEBUG << "Setting the Hypervisor subnet : " << subnet
390d5afb2caSAndrew Geissler                      << " on Iface: " << ethIfaceId;
391d5afb2caSAndrew Geissler 
392d5afb2caSAndrew Geissler     crow::connections::systemBus->async_method_call(
393d5afb2caSAndrew Geissler         [aResp](const boost::system::error_code ec) {
394d5afb2caSAndrew Geissler             if (ec)
395d5afb2caSAndrew Geissler             {
396d5afb2caSAndrew Geissler                 BMCWEB_LOG_ERROR << "DBUS response error " << ec;
397d5afb2caSAndrew Geissler                 return;
398d5afb2caSAndrew Geissler             }
399d5afb2caSAndrew Geissler             BMCWEB_LOG_DEBUG << "SubnetMask is Set";
400d5afb2caSAndrew Geissler         },
401d5afb2caSAndrew Geissler         "xyz.openbmc_project.Settings",
402d5afb2caSAndrew Geissler         "/xyz/openbmc_project/network/hypervisor/" + ethIfaceId + "/ipv4/addr0",
403d5afb2caSAndrew Geissler         "org.freedesktop.DBus.Properties", "Set",
404d5afb2caSAndrew Geissler         "xyz.openbmc_project.Network.IP", "PrefixLength",
405168e20c1SEd Tanous         dbus::utility::DbusVariantType(subnet));
406d5afb2caSAndrew Geissler }
407d5afb2caSAndrew Geissler 
408d5afb2caSAndrew Geissler /**
409d5afb2caSAndrew Geissler  * @brief Sets the Hypervisor Interface Gateway DBUS
410d5afb2caSAndrew Geissler  *
411d5afb2caSAndrew Geissler  * @param[in] aResp          Shared pointer for generating response message.
412d5afb2caSAndrew Geissler  * @param[in] gateway        Gateway from the incoming request
413d5afb2caSAndrew Geissler  * @param[in] ethIfaceId     Hypervisor Interface Id
414d5afb2caSAndrew Geissler  *
415d5afb2caSAndrew Geissler  * @return None.
416d5afb2caSAndrew Geissler  */
4178d1b46d7Szhanghch05 inline void
4188d1b46d7Szhanghch05     setHypervisorIPv4Gateway(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
419d5afb2caSAndrew Geissler                              const std::string& gateway)
420d5afb2caSAndrew Geissler {
421d5afb2caSAndrew Geissler     BMCWEB_LOG_DEBUG
422d5afb2caSAndrew Geissler         << "Setting the DefaultGateway to the last configured gateway";
423d5afb2caSAndrew Geissler 
424d5afb2caSAndrew Geissler     crow::connections::systemBus->async_method_call(
425d5afb2caSAndrew Geissler         [aResp](const boost::system::error_code ec) {
426d5afb2caSAndrew Geissler             if (ec)
427d5afb2caSAndrew Geissler             {
428d5afb2caSAndrew Geissler                 BMCWEB_LOG_ERROR << "DBUS response error " << ec;
429d5afb2caSAndrew Geissler                 return;
430d5afb2caSAndrew Geissler             }
431d5afb2caSAndrew Geissler             BMCWEB_LOG_DEBUG << "Default Gateway is Set";
432d5afb2caSAndrew Geissler         },
433d5afb2caSAndrew Geissler         "xyz.openbmc_project.Settings",
434d5afb2caSAndrew Geissler         "/xyz/openbmc_project/network/hypervisor",
435d5afb2caSAndrew Geissler         "org.freedesktop.DBus.Properties", "Set",
436d5afb2caSAndrew Geissler         "xyz.openbmc_project.Network.SystemConfiguration", "DefaultGateway",
437168e20c1SEd Tanous         dbus::utility::DbusVariantType(gateway));
438d5afb2caSAndrew Geissler }
439d5afb2caSAndrew Geissler 
440d5afb2caSAndrew Geissler /**
441d5afb2caSAndrew Geissler  * @brief Creates a static IPv4 entry
442d5afb2caSAndrew Geissler  *
443d5afb2caSAndrew Geissler  * @param[in] ifaceId      Id of interface upon which to create the IPv4 entry
444d5afb2caSAndrew Geissler  * @param[in] prefixLength IPv4 prefix syntax for the subnet mask
445d5afb2caSAndrew Geissler  * @param[in] gateway      IPv4 address of this interfaces gateway
446d5afb2caSAndrew Geissler  * @param[in] address      IPv4 address to assign to this interface
447d5afb2caSAndrew Geissler  * @param[io] asyncResp    Response object that will be returned to client
448d5afb2caSAndrew Geissler  *
449d5afb2caSAndrew Geissler  * @return None
450d5afb2caSAndrew Geissler  */
4518d1b46d7Szhanghch05 inline void
4528d1b46d7Szhanghch05     createHypervisorIPv4(const std::string& ifaceId, uint8_t prefixLength,
4538d1b46d7Szhanghch05                          const std::string& gateway, const std::string& address,
4548d1b46d7Szhanghch05                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
455d5afb2caSAndrew Geissler {
456d5afb2caSAndrew Geissler     setHypervisorIPv4Address(asyncResp, ifaceId, address);
457d5afb2caSAndrew Geissler     setHypervisorIPv4Gateway(asyncResp, gateway);
458d5afb2caSAndrew Geissler     setHypervisorIPv4Subnet(asyncResp, ifaceId, prefixLength);
459d5afb2caSAndrew Geissler }
460d5afb2caSAndrew Geissler 
461d5afb2caSAndrew Geissler /**
462d5afb2caSAndrew Geissler  * @brief Deletes given IPv4 interface
463d5afb2caSAndrew Geissler  *
464d5afb2caSAndrew Geissler  * @param[in] ifaceId     Id of interface whose IP should be deleted
465d5afb2caSAndrew Geissler  * @param[io] asyncResp   Response object that will be returned to client
466d5afb2caSAndrew Geissler  *
467d5afb2caSAndrew Geissler  * @return None
468d5afb2caSAndrew Geissler  */
4698d1b46d7Szhanghch05 inline void
4708d1b46d7Szhanghch05     deleteHypervisorIPv4(const std::string& ifaceId,
4718d1b46d7Szhanghch05                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
472d5afb2caSAndrew Geissler {
473d5afb2caSAndrew Geissler     std::string address = "0.0.0.0";
474d5afb2caSAndrew Geissler     std::string gateway = "0.0.0.0";
475d5afb2caSAndrew Geissler     const uint8_t prefixLength = 0;
476d5afb2caSAndrew Geissler     setHypervisorIPv4Address(asyncResp, ifaceId, address);
477d5afb2caSAndrew Geissler     setHypervisorIPv4Gateway(asyncResp, gateway);
478d5afb2caSAndrew Geissler     setHypervisorIPv4Subnet(asyncResp, ifaceId, prefixLength);
479d5afb2caSAndrew Geissler }
480d5afb2caSAndrew Geissler 
4817e860f15SJohn Edward Broadbent inline void parseInterfaceData(
482d5afb2caSAndrew Geissler     nlohmann::json& jsonResponse, const std::string& ifaceId,
483d5afb2caSAndrew Geissler     const EthernetInterfaceData& ethData,
484d5afb2caSAndrew Geissler     const boost::container::flat_set<IPv4AddressData>& ipv4Data)
485d5afb2caSAndrew Geissler {
486d5afb2caSAndrew Geissler     jsonResponse["Id"] = ifaceId;
487d5afb2caSAndrew Geissler     jsonResponse["@odata.id"] =
488d5afb2caSAndrew Geissler         "/redfish/v1/Systems/hypervisor/EthernetInterfaces/" + ifaceId;
489d5afb2caSAndrew Geissler     jsonResponse["InterfaceEnabled"] = true;
49082695a5bSJiaqing Zhao     jsonResponse["MACAddress"] = ethData.macAddress;
491d5afb2caSAndrew Geissler 
49282695a5bSJiaqing Zhao     jsonResponse["HostName"] = ethData.hostName;
493d5afb2caSAndrew Geissler     jsonResponse["DHCPv4"]["DHCPEnabled"] =
49482695a5bSJiaqing Zhao         translateDhcpEnabledToBool(ethData.dhcpEnabled, true);
495d5afb2caSAndrew Geissler 
496d5afb2caSAndrew Geissler     nlohmann::json& ipv4Array = jsonResponse["IPv4Addresses"];
497d5afb2caSAndrew Geissler     nlohmann::json& ipv4StaticArray = jsonResponse["IPv4StaticAddresses"];
498d5afb2caSAndrew Geissler     ipv4Array = nlohmann::json::array();
499d5afb2caSAndrew Geissler     ipv4StaticArray = nlohmann::json::array();
5009eb808c1SEd Tanous     for (const auto& ipv4Config : ipv4Data)
501d5afb2caSAndrew Geissler     {
502d5afb2caSAndrew Geissler         if (ipv4Config.isActive)
503d5afb2caSAndrew Geissler         {
504*1476687dSEd Tanous             nlohmann::json::object_t ipv4;
505*1476687dSEd Tanous             ipv4["AddressOrigin"] = ipv4Config.origin;
506*1476687dSEd Tanous             ipv4["SubnetMask"] = ipv4Config.netmask;
507*1476687dSEd Tanous             ipv4["Address"] = ipv4Config.address;
508*1476687dSEd Tanous             ipv4["Gateway"] = ethData.defaultGateway;
509d5afb2caSAndrew Geissler 
510d5afb2caSAndrew Geissler             if (ipv4Config.origin == "Static")
511d5afb2caSAndrew Geissler             {
512*1476687dSEd Tanous                 ipv4StaticArray.push_back(ipv4);
513d5afb2caSAndrew Geissler             }
514*1476687dSEd Tanous             ipv4Array.push_back(std::move(ipv4));
515d5afb2caSAndrew Geissler         }
516d5afb2caSAndrew Geissler     }
517d5afb2caSAndrew Geissler }
518d5afb2caSAndrew Geissler 
5197e860f15SJohn Edward Broadbent inline void setDHCPEnabled(const std::string& ifaceId,
5207e860f15SJohn Edward Broadbent                            const bool& ipv4DHCPEnabled,
5218d1b46d7Szhanghch05                            const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
522d5afb2caSAndrew Geissler {
5237e860f15SJohn Edward Broadbent     const std::string dhcp = getDhcpEnabledEnumeration(ipv4DHCPEnabled, false);
524d5afb2caSAndrew Geissler     crow::connections::systemBus->async_method_call(
525d5afb2caSAndrew Geissler         [asyncResp](const boost::system::error_code ec) {
526d5afb2caSAndrew Geissler             if (ec)
527d5afb2caSAndrew Geissler             {
528d5afb2caSAndrew Geissler                 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
529d5afb2caSAndrew Geissler                 messages::internalError(asyncResp->res);
530d5afb2caSAndrew Geissler                 return;
531d5afb2caSAndrew Geissler             }
532d5afb2caSAndrew Geissler         },
533d5afb2caSAndrew Geissler         "xyz.openbmc_project.Settings",
534d5afb2caSAndrew Geissler         "/xyz/openbmc_project/network/hypervisor/" + ifaceId,
535d5afb2caSAndrew Geissler         "org.freedesktop.DBus.Properties", "Set",
536d5afb2caSAndrew Geissler         "xyz.openbmc_project.Network.EthernetInterface", "DHCPEnabled",
537168e20c1SEd Tanous         dbus::utility::DbusVariantType{dhcp});
538d5afb2caSAndrew Geissler 
539d5afb2caSAndrew Geissler     // Set the IPv4 address origin to the DHCP / Static as per the new value
540d5afb2caSAndrew Geissler     // of the DHCPEnabled property
541d5afb2caSAndrew Geissler     std::string origin;
542e05aec50SEd Tanous     if (!ipv4DHCPEnabled)
543d5afb2caSAndrew Geissler     {
544d5afb2caSAndrew Geissler         origin = "xyz.openbmc_project.Network.IP.AddressOrigin.Static";
545d5afb2caSAndrew Geissler     }
546d5afb2caSAndrew Geissler     else
547d5afb2caSAndrew Geissler     {
548d5afb2caSAndrew Geissler         // DHCPEnabled is set to true. Delete the current IPv4 settings
549d5afb2caSAndrew Geissler         // to receive the new values from DHCP server.
550d5afb2caSAndrew Geissler         deleteHypervisorIPv4(ifaceId, asyncResp);
551d5afb2caSAndrew Geissler         origin = "xyz.openbmc_project.Network.IP.AddressOrigin.DHCP";
552d5afb2caSAndrew Geissler     }
553d5afb2caSAndrew Geissler     crow::connections::systemBus->async_method_call(
554d5afb2caSAndrew Geissler         [asyncResp](const boost::system::error_code ec) {
555d5afb2caSAndrew Geissler             if (ec)
556d5afb2caSAndrew Geissler             {
557d5afb2caSAndrew Geissler                 BMCWEB_LOG_ERROR << "DBUS response error " << ec;
558d5afb2caSAndrew Geissler                 messages::internalError(asyncResp->res);
559d5afb2caSAndrew Geissler                 return;
560d5afb2caSAndrew Geissler             }
561d5afb2caSAndrew Geissler             BMCWEB_LOG_DEBUG << "Hypervisor IPaddress Origin is Set";
562d5afb2caSAndrew Geissler         },
563d5afb2caSAndrew Geissler         "xyz.openbmc_project.Settings",
5647e860f15SJohn Edward Broadbent         "/xyz/openbmc_project/network/hypervisor/" + ifaceId + "/ipv4/addr0",
565d5afb2caSAndrew Geissler         "org.freedesktop.DBus.Properties", "Set",
566d5afb2caSAndrew Geissler         "xyz.openbmc_project.Network.IP", "Origin",
567168e20c1SEd Tanous         dbus::utility::DbusVariantType(origin));
568d5afb2caSAndrew Geissler }
569d5afb2caSAndrew Geissler 
5707e860f15SJohn Edward Broadbent inline void handleHypervisorIPv4StaticPatch(
5717e860f15SJohn Edward Broadbent     const std::string& ifaceId, const nlohmann::json& input,
5727e860f15SJohn Edward Broadbent     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
573d5afb2caSAndrew Geissler {
5747e860f15SJohn Edward Broadbent     if ((!input.is_array()) || input.empty())
575d5afb2caSAndrew Geissler     {
5767e860f15SJohn Edward Broadbent         messages::propertyValueTypeError(asyncResp->res, input.dump(),
5777e860f15SJohn Edward Broadbent                                          "IPv4StaticAddresses");
578d5afb2caSAndrew Geissler         return;
579d5afb2caSAndrew Geissler     }
580d5afb2caSAndrew Geissler 
5817e860f15SJohn Edward Broadbent     // Hypervisor considers the first IP address in the array list
5827e860f15SJohn Edward Broadbent     // as the Hypervisor's virtual management interface supports single IPv4
5837e860f15SJohn Edward Broadbent     // address
5847e860f15SJohn Edward Broadbent     const nlohmann::json& thisJson = input[0];
5857e860f15SJohn Edward Broadbent 
5867e860f15SJohn Edward Broadbent     // For the error string
5877e860f15SJohn Edward Broadbent     std::string pathString = "IPv4StaticAddresses/1";
5887e860f15SJohn Edward Broadbent 
5897e860f15SJohn Edward Broadbent     if (!thisJson.is_null() && !thisJson.empty())
5907e860f15SJohn Edward Broadbent     {
5917e860f15SJohn Edward Broadbent         std::optional<std::string> address;
5927e860f15SJohn Edward Broadbent         std::optional<std::string> subnetMask;
5937e860f15SJohn Edward Broadbent         std::optional<std::string> gateway;
5947e860f15SJohn Edward Broadbent         nlohmann::json thisJsonCopy = thisJson;
5957e860f15SJohn Edward Broadbent         if (!json_util::readJson(thisJsonCopy, asyncResp->res, "Address",
5967e860f15SJohn Edward Broadbent                                  address, "SubnetMask", subnetMask, "Gateway",
5977e860f15SJohn Edward Broadbent                                  gateway))
5987e860f15SJohn Edward Broadbent         {
5997e860f15SJohn Edward Broadbent             messages::propertyValueFormatError(
6007e860f15SJohn Edward Broadbent                 asyncResp->res,
6017e860f15SJohn Edward Broadbent                 thisJson.dump(2, ' ', true,
6027e860f15SJohn Edward Broadbent                               nlohmann::json::error_handler_t::replace),
6037e860f15SJohn Edward Broadbent                 pathString);
6047e860f15SJohn Edward Broadbent             return;
6057e860f15SJohn Edward Broadbent         }
6067e860f15SJohn Edward Broadbent 
6077e860f15SJohn Edward Broadbent         uint8_t prefixLength = 0;
6087e860f15SJohn Edward Broadbent         bool errorInEntry = false;
6097e860f15SJohn Edward Broadbent         if (address)
6107e860f15SJohn Edward Broadbent         {
6117e860f15SJohn Edward Broadbent             if (!ipv4VerifyIpAndGetBitcount(*address))
6127e860f15SJohn Edward Broadbent             {
6137e860f15SJohn Edward Broadbent                 messages::propertyValueFormatError(asyncResp->res, *address,
6147e860f15SJohn Edward Broadbent                                                    pathString + "/Address");
6157e860f15SJohn Edward Broadbent                 errorInEntry = true;
6167e860f15SJohn Edward Broadbent             }
6177e860f15SJohn Edward Broadbent         }
6187e860f15SJohn Edward Broadbent         else
6197e860f15SJohn Edward Broadbent         {
6207e860f15SJohn Edward Broadbent             messages::propertyMissing(asyncResp->res, pathString + "/Address");
6217e860f15SJohn Edward Broadbent             errorInEntry = true;
6227e860f15SJohn Edward Broadbent         }
6237e860f15SJohn Edward Broadbent 
6247e860f15SJohn Edward Broadbent         if (subnetMask)
6257e860f15SJohn Edward Broadbent         {
6267e860f15SJohn Edward Broadbent             if (!ipv4VerifyIpAndGetBitcount(*subnetMask, &prefixLength))
6277e860f15SJohn Edward Broadbent             {
6287e860f15SJohn Edward Broadbent                 messages::propertyValueFormatError(asyncResp->res, *subnetMask,
6297e860f15SJohn Edward Broadbent                                                    pathString + "/SubnetMask");
6307e860f15SJohn Edward Broadbent                 errorInEntry = true;
6317e860f15SJohn Edward Broadbent             }
6327e860f15SJohn Edward Broadbent         }
6337e860f15SJohn Edward Broadbent         else
6347e860f15SJohn Edward Broadbent         {
6357e860f15SJohn Edward Broadbent             messages::propertyMissing(asyncResp->res,
6367e860f15SJohn Edward Broadbent                                       pathString + "/SubnetMask");
6377e860f15SJohn Edward Broadbent             errorInEntry = true;
6387e860f15SJohn Edward Broadbent         }
6397e860f15SJohn Edward Broadbent 
6407e860f15SJohn Edward Broadbent         if (gateway)
6417e860f15SJohn Edward Broadbent         {
6427e860f15SJohn Edward Broadbent             if (!ipv4VerifyIpAndGetBitcount(*gateway))
6437e860f15SJohn Edward Broadbent             {
6447e860f15SJohn Edward Broadbent                 messages::propertyValueFormatError(asyncResp->res, *gateway,
6457e860f15SJohn Edward Broadbent                                                    pathString + "/Gateway");
6467e860f15SJohn Edward Broadbent                 errorInEntry = true;
6477e860f15SJohn Edward Broadbent             }
6487e860f15SJohn Edward Broadbent         }
6497e860f15SJohn Edward Broadbent         else
6507e860f15SJohn Edward Broadbent         {
6517e860f15SJohn Edward Broadbent             messages::propertyMissing(asyncResp->res, pathString + "/Gateway");
6527e860f15SJohn Edward Broadbent             errorInEntry = true;
6537e860f15SJohn Edward Broadbent         }
6547e860f15SJohn Edward Broadbent 
6557e860f15SJohn Edward Broadbent         if (errorInEntry)
6567e860f15SJohn Edward Broadbent         {
6577e860f15SJohn Edward Broadbent             return;
6587e860f15SJohn Edward Broadbent         }
6597e860f15SJohn Edward Broadbent 
6607e860f15SJohn Edward Broadbent         BMCWEB_LOG_DEBUG << "Calling createHypervisorIPv4 on : " << ifaceId
6617e860f15SJohn Edward Broadbent                          << "," << *address;
6627e860f15SJohn Edward Broadbent         createHypervisorIPv4(ifaceId, prefixLength, *gateway, *address,
6637e860f15SJohn Edward Broadbent                              asyncResp);
6647e860f15SJohn Edward Broadbent         // Set the DHCPEnabled to false since the Static IPv4 is set
6657e860f15SJohn Edward Broadbent         setDHCPEnabled(ifaceId, false, asyncResp);
6667e860f15SJohn Edward Broadbent     }
6677e860f15SJohn Edward Broadbent     else
6687e860f15SJohn Edward Broadbent     {
6697e860f15SJohn Edward Broadbent         if (thisJson.is_null())
6707e860f15SJohn Edward Broadbent         {
6717e860f15SJohn Edward Broadbent             deleteHypervisorIPv4(ifaceId, asyncResp);
6727e860f15SJohn Edward Broadbent         }
6737e860f15SJohn Edward Broadbent     }
6747e860f15SJohn Edward Broadbent }
6757e860f15SJohn Edward Broadbent 
6767e860f15SJohn Edward Broadbent inline void
6777e860f15SJohn Edward Broadbent     handleHostnamePatch(const std::string& hostName,
6787e860f15SJohn Edward Broadbent                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
6797e860f15SJohn Edward Broadbent {
6807e860f15SJohn Edward Broadbent     if (!isHostnameValid(hostName))
6817e860f15SJohn Edward Broadbent     {
6827e860f15SJohn Edward Broadbent         messages::propertyValueFormatError(asyncResp->res, hostName,
6837e860f15SJohn Edward Broadbent                                            "HostName");
6847e860f15SJohn Edward Broadbent         return;
6857e860f15SJohn Edward Broadbent     }
6867e860f15SJohn Edward Broadbent 
6877e860f15SJohn Edward Broadbent     asyncResp->res.jsonValue["HostName"] = hostName;
6887e860f15SJohn Edward Broadbent     crow::connections::systemBus->async_method_call(
6897e860f15SJohn Edward Broadbent         [asyncResp](const boost::system::error_code ec) {
6907e860f15SJohn Edward Broadbent             if (ec)
6917e860f15SJohn Edward Broadbent             {
6927e860f15SJohn Edward Broadbent                 messages::internalError(asyncResp->res);
6937e860f15SJohn Edward Broadbent             }
6947e860f15SJohn Edward Broadbent         },
6957e860f15SJohn Edward Broadbent         "xyz.openbmc_project.Settings",
6967e860f15SJohn Edward Broadbent         "/xyz/openbmc_project/network/hypervisor",
6977e860f15SJohn Edward Broadbent         "org.freedesktop.DBus.Properties", "Set",
6987e860f15SJohn Edward Broadbent         "xyz.openbmc_project.Network.SystemConfiguration", "HostName",
699168e20c1SEd Tanous         dbus::utility::DbusVariantType(hostName));
7007e860f15SJohn Edward Broadbent }
7017e860f15SJohn Edward Broadbent 
7027e860f15SJohn Edward Broadbent inline void
7037e860f15SJohn Edward Broadbent     setIPv4InterfaceEnabled(const std::string& ifaceId, const bool& isActive,
7047e860f15SJohn Edward Broadbent                             const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
7057e860f15SJohn Edward Broadbent {
7067e860f15SJohn Edward Broadbent     crow::connections::systemBus->async_method_call(
7077e860f15SJohn Edward Broadbent         [asyncResp](const boost::system::error_code ec) {
7087e860f15SJohn Edward Broadbent             if (ec)
7097e860f15SJohn Edward Broadbent             {
7107e860f15SJohn Edward Broadbent                 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
7117e860f15SJohn Edward Broadbent                 messages::internalError(asyncResp->res);
7127e860f15SJohn Edward Broadbent                 return;
7137e860f15SJohn Edward Broadbent             }
7147e860f15SJohn Edward Broadbent         },
7157e860f15SJohn Edward Broadbent         "xyz.openbmc_project.Settings",
7167e860f15SJohn Edward Broadbent         "/xyz/openbmc_project/network/hypervisor/" + ifaceId + "/ipv4/addr0",
7177e860f15SJohn Edward Broadbent         "org.freedesktop.DBus.Properties", "Set",
7187e860f15SJohn Edward Broadbent         "xyz.openbmc_project.Object.Enable", "Enabled",
719168e20c1SEd Tanous         dbus::utility::DbusVariantType(isActive));
7207e860f15SJohn Edward Broadbent }
7217e860f15SJohn Edward Broadbent 
7227e860f15SJohn Edward Broadbent inline void requestRoutesHypervisorSystems(App& app)
7237e860f15SJohn Edward Broadbent {
7247e860f15SJohn Edward Broadbent     /**
7257e860f15SJohn Edward Broadbent      * Hypervisor Systems derived class for delivering Computer Systems Schema.
7267e860f15SJohn Edward Broadbent      */
7277e860f15SJohn Edward Broadbent 
7287e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app, "/redfish/v1/Systems/hypervisor/")
729ed398213SEd Tanous         .privileges(redfish::privileges::getComputerSystem)
730*1476687dSEd Tanous         .methods(boost::beast::http::verb::get)(
731*1476687dSEd Tanous             [&app](const crow::Request& req,
732*1476687dSEd Tanous                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
73345ca1b86SEd Tanous                 if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
73445ca1b86SEd Tanous                 {
73545ca1b86SEd Tanous                     return;
73645ca1b86SEd Tanous                 }
7371e1e598dSJonathan Doman                 sdbusplus::asio::getProperty<std::string>(
738*1476687dSEd Tanous                     *crow::connections::systemBus,
739*1476687dSEd Tanous                     "xyz.openbmc_project.Settings",
7401e1e598dSJonathan Doman                     "/xyz/openbmc_project/network/hypervisor",
741*1476687dSEd Tanous                     "xyz.openbmc_project.Network.SystemConfiguration",
742*1476687dSEd Tanous                     "HostName",
7431e1e598dSJonathan Doman                     [asyncResp](const boost::system::error_code ec,
7441e1e598dSJonathan Doman                                 const std::string& /*hostName*/) {
7457e860f15SJohn Edward Broadbent                         if (ec)
7467e860f15SJohn Edward Broadbent                         {
7477e860f15SJohn Edward Broadbent                             messages::resourceNotFound(asyncResp->res, "System",
7487e860f15SJohn Edward Broadbent                                                        "hypervisor");
7497e860f15SJohn Edward Broadbent                             return;
7507e860f15SJohn Edward Broadbent                         }
7517e860f15SJohn Edward Broadbent                         BMCWEB_LOG_DEBUG << "Hypervisor is available";
7527e860f15SJohn Edward Broadbent 
7537e860f15SJohn Edward Broadbent                         asyncResp->res.jsonValue["@odata.type"] =
7547e860f15SJohn Edward Broadbent                             "#ComputerSystem.v1_6_0.ComputerSystem";
7557e860f15SJohn Edward Broadbent                         asyncResp->res.jsonValue["@odata.id"] =
7567e860f15SJohn Edward Broadbent                             "/redfish/v1/Systems/hypervisor";
7577e860f15SJohn Edward Broadbent                         asyncResp->res.jsonValue["Description"] = "Hypervisor";
7587e860f15SJohn Edward Broadbent                         asyncResp->res.jsonValue["Name"] = "Hypervisor";
7597e860f15SJohn Edward Broadbent                         asyncResp->res.jsonValue["Id"] = "hypervisor";
760056350beSAli Ahmed                         asyncResp->res.jsonValue["SystemType"] = "OS";
761*1476687dSEd Tanous                         nlohmann::json::array_t managedBy;
762*1476687dSEd Tanous                         nlohmann::json::object_t manager;
763*1476687dSEd Tanous                         manager["@odata.id"] = "/redfish/v1/Managers/bmc";
764*1476687dSEd Tanous                         managedBy.push_back(std::move(manager));
765*1476687dSEd Tanous                         asyncResp->res.jsonValue["Links"]["ManagedBy"] =
766*1476687dSEd Tanous                             std::move(managedBy);
767*1476687dSEd Tanous                         asyncResp->res
768*1476687dSEd Tanous                             .jsonValue["EthernetInterfaces"]["@odata.id"] =
769*1476687dSEd Tanous                             "/redfish/v1/Systems/hypervisor/EthernetInterfaces";
7707e860f15SJohn Edward Broadbent                         getHypervisorState(asyncResp);
7717e860f15SJohn Edward Broadbent                         getHypervisorActions(asyncResp);
7727e860f15SJohn Edward Broadbent                         // TODO: Add "SystemType" : "hypervisor"
7731e1e598dSJonathan Doman                     });
7747e860f15SJohn Edward Broadbent             });
7757e860f15SJohn Edward Broadbent 
7767e860f15SJohn Edward Broadbent     /**
7777e860f15SJohn Edward Broadbent      * HypervisorInterfaceCollection class to handle the GET and PATCH on
7787e860f15SJohn Edward Broadbent      * Hypervisor Interface
7797e860f15SJohn Edward Broadbent      */
7807e860f15SJohn Edward Broadbent 
7817e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app, "/redfish/v1/Systems/hypervisor/EthernetInterfaces/")
782ed398213SEd Tanous         .privileges(redfish::privileges::getEthernetInterfaceCollection)
78345ca1b86SEd Tanous         .methods(boost::beast::http::verb::get)([&app](const crow::Request& req,
78445ca1b86SEd Tanous                                                        const std::shared_ptr<
78545ca1b86SEd Tanous                                                            bmcweb::AsyncResp>&
78645ca1b86SEd Tanous                                                            asyncResp) {
78745ca1b86SEd Tanous             if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
78845ca1b86SEd Tanous             {
78945ca1b86SEd Tanous                 return;
79045ca1b86SEd Tanous             }
7917e860f15SJohn Edward Broadbent             const std::array<const char*, 1> interfaces = {
7927e860f15SJohn Edward Broadbent                 "xyz.openbmc_project.Network.EthernetInterface"};
7937e860f15SJohn Edward Broadbent 
7947e860f15SJohn Edward Broadbent             crow::connections::systemBus->async_method_call(
7957e860f15SJohn Edward Broadbent                 [asyncResp](const boost::system::error_code error,
796b9d36b47SEd Tanous                             const dbus::utility::MapperGetSubTreePathsResponse&
797b9d36b47SEd Tanous                                 ifaceList) {
7987e860f15SJohn Edward Broadbent                     if (error)
7997e860f15SJohn Edward Broadbent                     {
8007e860f15SJohn Edward Broadbent                         messages::resourceNotFound(asyncResp->res, "System",
8017e860f15SJohn Edward Broadbent                                                    "hypervisor");
8027e860f15SJohn Edward Broadbent                         return;
8037e860f15SJohn Edward Broadbent                     }
8047e860f15SJohn Edward Broadbent                     asyncResp->res.jsonValue["@odata.type"] =
8057e860f15SJohn Edward Broadbent                         "#EthernetInterfaceCollection."
8067e860f15SJohn Edward Broadbent                         "EthernetInterfaceCollection";
8077e860f15SJohn Edward Broadbent                     asyncResp->res.jsonValue["@odata.id"] =
8087e860f15SJohn Edward Broadbent                         "/redfish/v1/Systems/hypervisor/EthernetInterfaces";
8090fda0f12SGeorge Liu                     asyncResp->res.jsonValue["Name"] = "Hypervisor Ethernet "
8107e860f15SJohn Edward Broadbent                                                        "Interface Collection";
8117e860f15SJohn Edward Broadbent                     asyncResp->res.jsonValue["Description"] =
8127e860f15SJohn Edward Broadbent                         "Collection of Virtual Management "
8137e860f15SJohn Edward Broadbent                         "Interfaces for the hypervisor";
8147e860f15SJohn Edward Broadbent 
8157e860f15SJohn Edward Broadbent                     nlohmann::json& ifaceArray =
8167e860f15SJohn Edward Broadbent                         asyncResp->res.jsonValue["Members"];
8177e860f15SJohn Edward Broadbent                     ifaceArray = nlohmann::json::array();
8187e860f15SJohn Edward Broadbent                     for (const std::string& iface : ifaceList)
8197e860f15SJohn Edward Broadbent                     {
8207e860f15SJohn Edward Broadbent                         sdbusplus::message::object_path path(iface);
8217e860f15SJohn Edward Broadbent                         std::string name = path.filename();
8227e860f15SJohn Edward Broadbent                         if (name.empty())
8237e860f15SJohn Edward Broadbent                         {
8247e860f15SJohn Edward Broadbent                             continue;
8257e860f15SJohn Edward Broadbent                         }
826*1476687dSEd Tanous                         nlohmann::json::object_t ethIface;
827*1476687dSEd Tanous                         ethIface["@odata.id"] =
8280fda0f12SGeorge Liu                             "/redfish/v1/Systems/hypervisor/EthernetInterfaces/" +
829*1476687dSEd Tanous                             name;
830*1476687dSEd Tanous                         ifaceArray.push_back(std::move(ethIface));
8317e860f15SJohn Edward Broadbent                     }
8327e860f15SJohn Edward Broadbent                     asyncResp->res.jsonValue["Members@odata.count"] =
8337e860f15SJohn Edward Broadbent                         ifaceArray.size();
8347e860f15SJohn Edward Broadbent                 },
8357e860f15SJohn Edward Broadbent                 "xyz.openbmc_project.ObjectMapper",
8367e860f15SJohn Edward Broadbent                 "/xyz/openbmc_project/object_mapper",
8377e860f15SJohn Edward Broadbent                 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
8387e860f15SJohn Edward Broadbent                 "/xyz/openbmc_project/network/hypervisor", 0, interfaces);
8397e860f15SJohn Edward Broadbent         });
8407e860f15SJohn Edward Broadbent 
8417e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app,
8427e860f15SJohn Edward Broadbent                  "/redfish/v1/Systems/hypervisor/EthernetInterfaces/<str>/")
843ed398213SEd Tanous         .privileges(redfish::privileges::getEthernetInterface)
84445ca1b86SEd Tanous         .methods(boost::beast::http::verb::get)(
84545ca1b86SEd Tanous             [&app](const crow::Request& req,
84645ca1b86SEd Tanous                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
8477e860f15SJohn Edward Broadbent                    const std::string& id) {
84845ca1b86SEd Tanous                 if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
84945ca1b86SEd Tanous                 {
85045ca1b86SEd Tanous                     return;
85145ca1b86SEd Tanous                 }
85245ca1b86SEd Tanous                 getHypervisorIfaceData(id, [asyncResp,
85345ca1b86SEd Tanous                                             ifaceId{std::string(id)}](
85445ca1b86SEd Tanous                                                const bool& success,
85545ca1b86SEd Tanous                                                const EthernetInterfaceData&
85645ca1b86SEd Tanous                                                    ethData,
85745ca1b86SEd Tanous                                                const boost::container::flat_set<
85845ca1b86SEd Tanous                                                    IPv4AddressData>& ipv4Data) {
859d5afb2caSAndrew Geissler                     if (!success)
860d5afb2caSAndrew Geissler                     {
8617e860f15SJohn Edward Broadbent                         messages::resourceNotFound(
8627e860f15SJohn Edward Broadbent                             asyncResp->res, "EthernetInterface", ifaceId);
863d5afb2caSAndrew Geissler                         return;
864d5afb2caSAndrew Geissler                     }
865d5afb2caSAndrew Geissler                     asyncResp->res.jsonValue["@odata.type"] =
866d5afb2caSAndrew Geissler                         "#EthernetInterface.v1_5_1.EthernetInterface";
867d5afb2caSAndrew Geissler                     asyncResp->res.jsonValue["Name"] =
868d5afb2caSAndrew Geissler                         "Hypervisor Ethernet Interface";
869d5afb2caSAndrew Geissler                     asyncResp->res.jsonValue["Description"] =
870d5afb2caSAndrew Geissler                         "Hypervisor's Virtual Management Ethernet Interface";
8717e860f15SJohn Edward Broadbent                     parseInterfaceData(asyncResp->res.jsonValue, ifaceId,
8727e860f15SJohn Edward Broadbent                                        ethData, ipv4Data);
873d5afb2caSAndrew Geissler                 });
8747e860f15SJohn Edward Broadbent             });
875d5afb2caSAndrew Geissler 
8767e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app,
8777e860f15SJohn Edward Broadbent                  "/redfish/v1/Systems/hypervisor/EthernetInterfaces/<str>/")
878ed398213SEd Tanous         .privileges(redfish::privileges::patchEthernetInterface)
8797e860f15SJohn Edward Broadbent         .methods(
8807e860f15SJohn Edward Broadbent             boost::beast::http::verb::
88145ca1b86SEd Tanous                 patch)([&app](
88245ca1b86SEd Tanous                            const crow::Request& req,
8837e860f15SJohn Edward Broadbent                            const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
8847e860f15SJohn Edward Broadbent                            const std::string& ifaceId) {
88545ca1b86SEd Tanous             if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
88645ca1b86SEd Tanous             {
88745ca1b86SEd Tanous                 return;
88845ca1b86SEd Tanous             }
889d5afb2caSAndrew Geissler             std::optional<std::string> hostName;
89064face74SRavi Teja             std::optional<std::vector<nlohmann::json>> ipv4StaticAddresses;
891d5afb2caSAndrew Geissler             std::optional<nlohmann::json> ipv4Addresses;
892d5afb2caSAndrew Geissler             std::optional<nlohmann::json> dhcpv4;
893d5afb2caSAndrew Geissler             std::optional<bool> ipv4DHCPEnabled;
894d5afb2caSAndrew Geissler 
89515ed6780SWilly Tu             if (!json_util::readJsonPatch(req, asyncResp->res, "HostName",
89615ed6780SWilly Tu                                           hostName, "IPv4StaticAddresses",
89715ed6780SWilly Tu                                           ipv4StaticAddresses, "IPv4Addresses",
89815ed6780SWilly Tu                                           ipv4Addresses, "DHCPv4", dhcpv4))
899d5afb2caSAndrew Geissler             {
900d5afb2caSAndrew Geissler                 return;
901d5afb2caSAndrew Geissler             }
902d5afb2caSAndrew Geissler 
903d5afb2caSAndrew Geissler             if (ipv4Addresses)
904d5afb2caSAndrew Geissler             {
905d5afb2caSAndrew Geissler                 messages::propertyNotWritable(asyncResp->res, "IPv4Addresses");
906ff3f835aSRavi Teja                 return;
907d5afb2caSAndrew Geissler             }
908d5afb2caSAndrew Geissler 
909d5afb2caSAndrew Geissler             if (dhcpv4)
910d5afb2caSAndrew Geissler             {
9118d1b46d7Szhanghch05                 if (!json_util::readJson(*dhcpv4, asyncResp->res, "DHCPEnabled",
912d5afb2caSAndrew Geissler                                          ipv4DHCPEnabled))
913d5afb2caSAndrew Geissler                 {
914d5afb2caSAndrew Geissler                     return;
915d5afb2caSAndrew Geissler                 }
916d5afb2caSAndrew Geissler             }
917d5afb2caSAndrew Geissler 
918d5afb2caSAndrew Geissler             getHypervisorIfaceData(
919d5afb2caSAndrew Geissler                 ifaceId,
9207e860f15SJohn Edward Broadbent                 [asyncResp, ifaceId, hostName = std::move(hostName),
921d5afb2caSAndrew Geissler                  ipv4StaticAddresses = std::move(ipv4StaticAddresses),
922d5afb2caSAndrew Geissler                  ipv4DHCPEnabled, dhcpv4 = std::move(dhcpv4)](
923d5afb2caSAndrew Geissler                     const bool& success, const EthernetInterfaceData& ethData,
924d5afb2caSAndrew Geissler                     const boost::container::flat_set<IPv4AddressData>&) {
925d5afb2caSAndrew Geissler                     if (!success)
926d5afb2caSAndrew Geissler                     {
9277e860f15SJohn Edward Broadbent                         messages::resourceNotFound(
9287e860f15SJohn Edward Broadbent                             asyncResp->res, "EthernetInterface", ifaceId);
929d5afb2caSAndrew Geissler                         return;
930d5afb2caSAndrew Geissler                     }
931d5afb2caSAndrew Geissler 
932d5afb2caSAndrew Geissler                     if (ipv4StaticAddresses)
933d5afb2caSAndrew Geissler                     {
934d5afb2caSAndrew Geissler                         const nlohmann::json& ipv4Static = *ipv4StaticAddresses;
93564face74SRavi Teja                         if (ipv4Static.begin() == ipv4Static.end())
93664face74SRavi Teja                         {
93764face74SRavi Teja                             messages::propertyValueTypeError(
93864face74SRavi Teja                                 asyncResp->res,
93964face74SRavi Teja                                 ipv4Static.dump(
94064face74SRavi Teja                                     2, ' ', true,
94164face74SRavi Teja                                     nlohmann::json::error_handler_t::replace),
94264face74SRavi Teja                                 "IPv4StaticAddresses");
94364face74SRavi Teja                             return;
94464face74SRavi Teja                         }
94564face74SRavi Teja 
94664face74SRavi Teja                         // One and only one hypervisor instance supported
94764face74SRavi Teja                         if (ipv4Static.size() != 1)
94864face74SRavi Teja                         {
94964face74SRavi Teja                             messages::propertyValueFormatError(
95064face74SRavi Teja                                 asyncResp->res,
95164face74SRavi Teja                                 ipv4Static.dump(
95264face74SRavi Teja                                     2, ' ', true,
95364face74SRavi Teja                                     nlohmann::json::error_handler_t::replace),
95464face74SRavi Teja                                 "IPv4StaticAddresses");
95564face74SRavi Teja                             return;
95664face74SRavi Teja                         }
95764face74SRavi Teja 
958d5afb2caSAndrew Geissler                         const nlohmann::json& ipv4Json = ipv4Static[0];
9597e860f15SJohn Edward Broadbent                         // Check if the param is 'null'. If its null, it means
9607e860f15SJohn Edward Broadbent                         // that user wants to delete the IP address. Deleting
9617e860f15SJohn Edward Broadbent                         // the IP address is allowed only if its statically
9627e860f15SJohn Edward Broadbent                         // configured. Deleting the address originated from DHCP
9637e860f15SJohn Edward Broadbent                         // is not allowed.
964d5afb2caSAndrew Geissler                         if ((ipv4Json.is_null()) &&
96582695a5bSJiaqing Zhao                             (translateDhcpEnabledToBool(ethData.dhcpEnabled,
9667e860f15SJohn Edward Broadbent                                                         true)))
967d5afb2caSAndrew Geissler                         {
968d5afb2caSAndrew Geissler                             BMCWEB_LOG_INFO
969d5afb2caSAndrew Geissler                                 << "Ignoring the delete on ipv4StaticAddresses "
970d5afb2caSAndrew Geissler                                    "as the interface is DHCP enabled";
971d5afb2caSAndrew Geissler                         }
972d5afb2caSAndrew Geissler                         else
973d5afb2caSAndrew Geissler                         {
974d5afb2caSAndrew Geissler                             handleHypervisorIPv4StaticPatch(ifaceId, ipv4Static,
975d5afb2caSAndrew Geissler                                                             asyncResp);
976d5afb2caSAndrew Geissler                         }
977d5afb2caSAndrew Geissler                     }
978d5afb2caSAndrew Geissler 
979d5afb2caSAndrew Geissler                     if (hostName)
980d5afb2caSAndrew Geissler                     {
981d5afb2caSAndrew Geissler                         handleHostnamePatch(*hostName, asyncResp);
982d5afb2caSAndrew Geissler                     }
983d5afb2caSAndrew Geissler 
984d5afb2caSAndrew Geissler                     if (dhcpv4)
985d5afb2caSAndrew Geissler                     {
986d5afb2caSAndrew Geissler                         setDHCPEnabled(ifaceId, *ipv4DHCPEnabled, asyncResp);
987d5afb2caSAndrew Geissler                     }
988d5afb2caSAndrew Geissler 
9897e860f15SJohn Edward Broadbent                     // Set this interface to disabled/inactive. This will be set
9907e860f15SJohn Edward Broadbent                     // to enabled/active by the pldm once the hypervisor
9917e860f15SJohn Edward Broadbent                     // consumes the updated settings from the user.
992d5afb2caSAndrew Geissler                     setIPv4InterfaceEnabled(ifaceId, false, asyncResp);
993d5afb2caSAndrew Geissler                 });
9948d1b46d7Szhanghch05             asyncResp->res.result(boost::beast::http::status::accepted);
9957e860f15SJohn Edward Broadbent         });
9964fbaf64aSAndrew Geissler 
9977e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app, "/redfish/v1/Systems/hypervisor/ResetActionInfo/")
998ed398213SEd Tanous         .privileges(redfish::privileges::getActionInfo)
9997e860f15SJohn Edward Broadbent         .methods(boost::beast::http::verb::get)(
100045ca1b86SEd Tanous             [&app](const crow::Request& req,
10017e860f15SJohn Edward Broadbent                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
100245ca1b86SEd Tanous                 if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
100345ca1b86SEd Tanous                 {
100445ca1b86SEd Tanous                     return;
100545ca1b86SEd Tanous                 }
10064fbaf64aSAndrew Geissler                 // Only return action info if hypervisor D-Bus object present
10074fbaf64aSAndrew Geissler                 crow::connections::systemBus->async_method_call(
10087e860f15SJohn Edward Broadbent                     [asyncResp](
10097e860f15SJohn Edward Broadbent                         const boost::system::error_code ec,
10104fbaf64aSAndrew Geissler                         const std::vector<std::pair<
10114fbaf64aSAndrew Geissler                             std::string, std::vector<std::string>>>& objInfo) {
10124fbaf64aSAndrew Geissler                         if (ec)
10134fbaf64aSAndrew Geissler                         {
10144fbaf64aSAndrew Geissler                             BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
10154fbaf64aSAndrew Geissler 
10164fbaf64aSAndrew Geissler                             // No hypervisor objects found by mapper
10174fbaf64aSAndrew Geissler                             if (ec.value() == boost::system::errc::io_error)
10184fbaf64aSAndrew Geissler                             {
10197e860f15SJohn Edward Broadbent                                 messages::resourceNotFound(asyncResp->res,
10207e860f15SJohn Edward Broadbent                                                            "hypervisor",
10214fbaf64aSAndrew Geissler                                                            "ResetActionInfo");
10224fbaf64aSAndrew Geissler                                 return;
10234fbaf64aSAndrew Geissler                             }
10244fbaf64aSAndrew Geissler 
10254fbaf64aSAndrew Geissler                             messages::internalError(asyncResp->res);
10264fbaf64aSAndrew Geissler                             return;
10274fbaf64aSAndrew Geissler                         }
10284fbaf64aSAndrew Geissler 
10294fbaf64aSAndrew Geissler                         // One and only one hypervisor instance supported
10304fbaf64aSAndrew Geissler                         if (objInfo.size() != 1)
10314fbaf64aSAndrew Geissler                         {
10324fbaf64aSAndrew Geissler                             messages::internalError(asyncResp->res);
10334fbaf64aSAndrew Geissler                             return;
10344fbaf64aSAndrew Geissler                         }
10354fbaf64aSAndrew Geissler 
10367e860f15SJohn Edward Broadbent                         // The hypervisor object only support the ability to
10377e860f15SJohn Edward Broadbent                         // turn On The system object Action should be utilized
10387e860f15SJohn Edward Broadbent                         // for other operations
1039*1476687dSEd Tanous 
1040*1476687dSEd Tanous                         asyncResp->res.jsonValue["@odata.type"] =
1041*1476687dSEd Tanous                             "#ActionInfo.v1_1_2.ActionInfo";
1042*1476687dSEd Tanous                         asyncResp->res.jsonValue["@odata.id"] =
1043*1476687dSEd Tanous                             "/redfish/v1/Systems/hypervisor/ResetActionInfo";
1044*1476687dSEd Tanous                         asyncResp->res.jsonValue["Name"] = "Reset Action Info";
1045*1476687dSEd Tanous                         asyncResp->res.jsonValue["Id"] = "ResetActionInfo";
1046*1476687dSEd Tanous                         nlohmann::json::array_t parameters;
1047*1476687dSEd Tanous                         nlohmann::json::object_t parameter;
1048*1476687dSEd Tanous                         parameter["Name"] = "ResetType";
1049*1476687dSEd Tanous                         parameter["Required"] = true;
1050*1476687dSEd Tanous                         parameter["DataType"] = "String";
1051*1476687dSEd Tanous                         nlohmann::json::array_t allowed;
1052*1476687dSEd Tanous                         allowed.push_back("On");
1053*1476687dSEd Tanous                         parameter["AllowableValues"] = std::move(allowed);
1054*1476687dSEd Tanous                         parameters.push_back(std::move(parameter));
1055*1476687dSEd Tanous                         asyncResp->res.jsonValue["Parameters"] =
1056*1476687dSEd Tanous                             std::move(parameters);
10574fbaf64aSAndrew Geissler                     },
10584fbaf64aSAndrew Geissler                     "xyz.openbmc_project.ObjectMapper",
10594fbaf64aSAndrew Geissler                     "/xyz/openbmc_project/object_mapper",
10604fbaf64aSAndrew Geissler                     "xyz.openbmc_project.ObjectMapper", "GetObject",
10614fbaf64aSAndrew Geissler                     "/xyz/openbmc_project/state/hypervisor0",
10627e860f15SJohn Edward Broadbent                     std::array<const char*, 1>{
10637e860f15SJohn Edward Broadbent                         "xyz.openbmc_project.State.Host"});
10647e860f15SJohn Edward Broadbent             });
10654fbaf64aSAndrew Geissler 
10667e860f15SJohn Edward Broadbent     BMCWEB_ROUTE(app,
10674fbaf64aSAndrew Geissler                  "/redfish/v1/Systems/hypervisor/Actions/ComputerSystem.Reset/")
1068ed398213SEd Tanous         .privileges(redfish::privileges::postComputerSystem)
10697e860f15SJohn Edward Broadbent         .methods(boost::beast::http::verb::post)(
107045ca1b86SEd Tanous             [&app](const crow::Request& req,
10717e860f15SJohn Edward Broadbent                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
107245ca1b86SEd Tanous                 if (!redfish::setUpRedfishRoute(app, req, asyncResp->res))
107345ca1b86SEd Tanous                 {
107445ca1b86SEd Tanous                     return;
107545ca1b86SEd Tanous                 }
10764fbaf64aSAndrew Geissler                 std::optional<std::string> resetType;
107715ed6780SWilly Tu                 if (!json_util::readJsonAction(req, asyncResp->res, "ResetType",
10787e860f15SJohn Edward Broadbent                                                resetType))
10794fbaf64aSAndrew Geissler                 {
10804fbaf64aSAndrew Geissler                     // readJson adds appropriate error to response
10814fbaf64aSAndrew Geissler                     return;
10824fbaf64aSAndrew Geissler                 }
10834fbaf64aSAndrew Geissler 
10844fbaf64aSAndrew Geissler                 if (!resetType)
10854fbaf64aSAndrew Geissler                 {
10864fbaf64aSAndrew Geissler                     messages::actionParameterMissing(
10874fbaf64aSAndrew Geissler                         asyncResp->res, "ComputerSystem.Reset", "ResetType");
10884fbaf64aSAndrew Geissler                     return;
10894fbaf64aSAndrew Geissler                 }
10904fbaf64aSAndrew Geissler 
10914fbaf64aSAndrew Geissler                 // Hypervisor object only support On operation
10924fbaf64aSAndrew Geissler                 if (resetType != "On")
10934fbaf64aSAndrew Geissler                 {
10944fbaf64aSAndrew Geissler                     messages::propertyValueNotInList(asyncResp->res, *resetType,
10954fbaf64aSAndrew Geissler                                                      "ResetType");
10964fbaf64aSAndrew Geissler                     return;
10974fbaf64aSAndrew Geissler                 }
10984fbaf64aSAndrew Geissler 
10997e860f15SJohn Edward Broadbent                 std::string command =
11007e860f15SJohn Edward Broadbent                     "xyz.openbmc_project.State.Host.Transition.On";
11014fbaf64aSAndrew Geissler 
11024fbaf64aSAndrew Geissler                 crow::connections::systemBus->async_method_call(
11034fbaf64aSAndrew Geissler                     [asyncResp, resetType](const boost::system::error_code ec) {
11044fbaf64aSAndrew Geissler                         if (ec)
11054fbaf64aSAndrew Geissler                         {
11064fbaf64aSAndrew Geissler                             BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
11077e860f15SJohn Edward Broadbent                             if (ec.value() ==
11087e860f15SJohn Edward Broadbent                                 boost::asio::error::invalid_argument)
11094fbaf64aSAndrew Geissler                             {
11104fbaf64aSAndrew Geissler                                 messages::actionParameterNotSupported(
11114fbaf64aSAndrew Geissler                                     asyncResp->res, *resetType, "Reset");
11124fbaf64aSAndrew Geissler                                 return;
11134fbaf64aSAndrew Geissler                             }
11144fbaf64aSAndrew Geissler 
11157e860f15SJohn Edward Broadbent                             if (ec.value() ==
11167e860f15SJohn Edward Broadbent                                 boost::asio::error::host_unreachable)
11174fbaf64aSAndrew Geissler                             {
11187e860f15SJohn Edward Broadbent                                 messages::resourceNotFound(asyncResp->res,
11197e860f15SJohn Edward Broadbent                                                            "Actions", "Reset");
11204fbaf64aSAndrew Geissler                                 return;
11214fbaf64aSAndrew Geissler                             }
11224fbaf64aSAndrew Geissler 
11234fbaf64aSAndrew Geissler                             messages::internalError(asyncResp->res);
11244fbaf64aSAndrew Geissler                             return;
11254fbaf64aSAndrew Geissler                         }
11264fbaf64aSAndrew Geissler                         messages::success(asyncResp->res);
11274fbaf64aSAndrew Geissler                     },
11284fbaf64aSAndrew Geissler                     "xyz.openbmc_project.State.Hypervisor",
11294fbaf64aSAndrew Geissler                     "/xyz/openbmc_project/state/hypervisor0",
11304fbaf64aSAndrew Geissler                     "org.freedesktop.DBus.Properties", "Set",
11314fbaf64aSAndrew Geissler                     "xyz.openbmc_project.State.Host", "RequestedHostTransition",
1132168e20c1SEd Tanous                     dbus::utility::DbusVariantType{std::move(command)});
11337e860f15SJohn Edward Broadbent             });
11344fbaf64aSAndrew Geissler }
1135b8983957SEd Tanous } // namespace redfish::hypervisor
1136