Add multi-host support in systems.hpp

Add support for multi-host GET, POST and PATCH
request handling under the
/redfish/v1/Systems/{computerSystemId}/ redfish resource.

The change implements the getComputerSystemIndex function which
leverages the xyz.openbmc_project.ManagedHost interface to retrieve the
index corresponding to the host the request was made for, when
on a multi-host machine. On single-host the index always defaults
to 0. It is not the perfect solution, but it is a starting point
to introduce multi-host support to bmcweb, allowing for power control,
via redfish and in general something we can build from.
More efficient ways of doing things are already discussed,
but will need more time to design properly.

The implementation relies on the
experimental-redfish-multi-computer-system meson flag to give bmcweb an
indication, whether it is running on single- or multi-host and to drop
unsupported redfish resources for the time being.

All multi-host supported redfish URIs can be found in this listing:
https://gerrit.openbmc.org/c/openbmc/bmcweb/+/76118

Tested:
GET route has been tested with redfish service validator in qemu for
the romulus and yosemite4 machine. Validator passed, no regression
observed.

POST route has been manually tested in web-ui on single-host hardware.
All possible power controls worked as expected. For multi-host this
was tested manually with curl in qemu. After requesting the expected
changes have been observed on dbus.

PATCH route has been requested via curl
manually both on multi- and single-host for every property, that this
patch implements. After each request the
expected change has been observed on dbus.

Change-Id: I67c17c3dd7a354fa9a2ebbc56d4def7a7e788909
Signed-off-by: Oliver Brewka <oliver.brewka@9elements.com>

Author: mox669

redfish-core/include/utils/systems_utils.hpp

@@ -3,6 +3,7 @@
 #include "bmcweb_config.h"
 
 #include "async_resp.hpp"
+#include "dbus_singleton.hpp"
 #include "dbus_utility.hpp"
 #include "error_messages.hpp"
 #include "human_sort.hpp"
@@ -15,6 +16,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
@@ -115,4 +117,150 @@ inline void getSystemCollectionMembers(
         "/xyz/openbmc_project/inventory", 0, interfaces,
         std::bind_front(handleSystemCollectionMembers, asyncResp));
 }
+
+inline void getManagedHostProperty(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& systemName, const std::string& systemPath,
+    const std::string& serviceName,
+    std::function<void(const uint64_t computerSystemIndex)> callback)
+{
+    dbus::utility::getProperty<uint64_t>(
+        *crow::connections::systemBus, serviceName, systemPath,
+        "xyz.openbmc_project.Inventory.Decorator.ManagedHost", "HostIndex",
+        [asyncResp, systemName, systemPath, serviceName,
+         callback = std::move(callback)](const boost::system::error_code& ec,
+                                         const uint64_t hostIndex) {
+            if (ec)
+            {
+                BMCWEB_LOG_WARNING("DBUS response error {}", ec);
+                messages::resourceNotFound(asyncResp->res, "ComputerSystem",
+                                           systemName);
+                return;
+            }
+            BMCWEB_LOG_DEBUG("Got index {} for path {}", hostIndex, systemPath);
+            callback(hostIndex);
+        });
+}
+
+inline void afterGetComputerSystemSubTree(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& systemName,
+    std::function<void(const uint64_t computerSystemIndex)>& callback,
+    const boost::system::error_code& ec,
+    const dbus::utility::MapperGetSubTreeResponse& subtree)
+{
+    sdbusplus::message::object_path systemPath;
+    std::string serviceName;
+    if (ec)
+    {
+        if (ec.value() == boost::system::errc::io_error)
+        {
+            BMCWEB_LOG_WARNING("EIO - System not found");
+            messages::resourceNotFound(asyncResp->res, "ComputerSystem",
+                                       systemName);
+            return;
+        }
+
+        BMCWEB_LOG_ERROR("DBus method call failed with error {}", ec.value());
+        messages::internalError(asyncResp->res);
+        return;
+    }
+
+    const auto& found = std::ranges::find_if(
+        subtree,
+        [systemName](const std::pair<sdbusplus::message::object_path,
+                                     dbus::utility::MapperServiceMap>& elem) {
+            return elem.first.filename() == systemName;
+        });
+
+    if (found == subtree.end())
+    {
+        BMCWEB_LOG_ERROR("Failed to match systemName: {}", systemName);
+        messages::resourceNotFound(asyncResp->res, "ComputerSystem",
+                                   systemName);
+        return;
+    }
+
+    systemPath = found->first;
+    serviceName = found->second.begin()->first;
+
+    getManagedHostProperty(asyncResp, systemName, systemPath, serviceName,
+                           std::move(callback));
+}
+
+/**
+ * @brief Retrieve the index associated with the requested system based on the
+ * ManagedHost interface
+ *
+ * @param[i] asyncResp  Async response object
+ * @param[i] systemName The requested system
+ * @param[i] callback   Callback to call once the index has been found
+ *
+ * @return None
+ */
+inline void getComputerSystemIndex(
+    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+    const std::string& systemName,
+    std::function<void(const uint64_t computerSystemIndex)>&& callback)
+{
+    if constexpr (BMCWEB_EXPERIMENTAL_REDFISH_MULTI_COMPUTER_SYSTEM)
+    {
+        constexpr std::array<std::string_view, 1> interfaces{
+            "xyz.openbmc_project.Inventory.Decorator.ManagedHost"};
+        dbus::utility::getSubTree(
+            "/xyz/openbmc_project/inventory", 0, interfaces,
+            std::bind_front(afterGetComputerSystemSubTree, asyncResp,
+                            systemName, std::move(callback)));
+    }
+    else
+    {
+        // on single-host, fallback to index 0
+        BMCWEB_LOG_DEBUG(
+            "Single-host detected, fallback to computerSystemIndex 0");
+        callback(0);
+    }
+}
+
+inline sdbusplus::message::object_path getHostStateObjectPath(
+    const uint64_t computerSystemIndex)
+{
+    const sdbusplus::message::object_path hostStatePath(
+        "/xyz/openbmc_project/state/host" +
+        std::to_string(computerSystemIndex));
+
+    return hostStatePath;
+}
+
+inline std::string getHostStateServiceName(const uint64_t computerSystemIndex)
+{
+    std::string hostStateService = "xyz.openbmc_project.State.Host";
+    if constexpr (BMCWEB_EXPERIMENTAL_REDFISH_MULTI_COMPUTER_SYSTEM)
+    {
+        hostStateService += std::to_string(computerSystemIndex);
+    }
+
+    return hostStateService;
+}
+
+inline sdbusplus::message::object_path getChassisStateObjectPath(
+    const uint64_t computerSystemIndex)
+{
+    const sdbusplus::message::object_path chassisStatePath(
+        "/xyz/openbmc_project/state/chassis" +
+        std::to_string(computerSystemIndex));
+
+    return chassisStatePath;
+}
+
+inline std::string getChassisStateServiceName(
+    const uint64_t computerSystemIndex)
+{
+    std::string chassisStateService = "xyz.openbmc_project.State.Chassis";
+    if constexpr (BMCWEB_EXPERIMENTAL_REDFISH_MULTI_COMPUTER_SYSTEM)
+    {
+        chassisStateService += std::to_string(computerSystemIndex);
+    }
+
+    return chassisStateService;
+}
 } // namespace redfish

redfish-core/lib/processor.hpp

@@ -1086,7 +1086,6 @@ inline void requestRoutesOperatingConfigCollection(App& app)
                                            systemName);
                 return;
             }
-
             if (systemName != BMCWEB_REDFISH_SYSTEM_URI_NAME)
             {
                 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
@@ -1254,7 +1253,6 @@ inline void requestRoutesProcessorCollection(App& app)
                                            systemName);
                 return;
             }
-
             if (systemName != BMCWEB_REDFISH_SYSTEM_URI_NAME)
             {
                 messages::resourceNotFound(asyncResp->res, "ComputerSystem",