notify-service : Framework to initiate DBus notifications

- This change introduces framework APIs to initiate D-Bus notification
  calls when the configured notification Mode is set to DBus.
- Applications that need to receive notifications are expected to
  implement the corresponding D-Bus interface and method.
- The full implementation is not included in this change, as the PDI
  interface and methods are still under discussion.

Change-Id: I574a297bc850ef4fd797ae8b5f4c1533fc19bbc5
Signed-off-by: Arya K Padman <[email protected]>

Author: aryakpadman

src/notify_service.cpp

@@ -31,6 +31,86 @@ NotifyService::NotifyService(sdbusplus::async::context& ctx,
     ctx.spawn(init(ctx, notifyFilePath));
 }
 
+sdbusplus::async::task<std::string>
+    // NOLINTNEXTLINE
+    NotifyService::getDbusObjectPath(sdbusplus::async::context& ctx,
+                                     const std::string& service,
+                                     const std::string& interface)
+{
+    std::string objectPath{};
+
+    constexpr auto objMapper =
+        sdbusplus::async::proxy()
+            .service("xyz.openbmc_project.ObjectMapper")
+            .path("/xyz/openbmc_project/object_mapper")
+            .interface("xyz.openbmc_project.ObjectMapper");
+
+    using services = std::map<std::string, std::vector<std::string>>;
+    using paths = std::map<std::string, services>;
+    paths subTreesInfo = co_await objMapper.call<paths>(
+        ctx, "GetSubTree", "/", 0, std::vector<std::string>{interface});
+
+    // TODO : Change the logic with std::views
+    bool objPathFound{false};
+    for (const auto& [objPath, serviceInterfaceMap] : subTreesInfo)
+    {
+        for (const auto& [serviceName, interfaces] : serviceInterfaceMap)
+        {
+            if (serviceName == service)
+            {
+                objectPath = objPath;
+                objPathFound = true;
+                break;
+            }
+        }
+        if (objPathFound)
+        {
+            break;
+        }
+    }
+    if (!objPathFound)
+    {
+        lg2::error(
+            "Unable to find the object path which hosts the interface[{INTERFACE}],"
+            " of the service {SERVICE}",
+            "INTERFACE", interface, "SERVICE", service);
+        throw std::runtime_error("Unable to find the DBus object path");
+    }
+
+    co_return objectPath;
+}
+
+// NOLINTNEXTLINE
+sdbusplus::async::task<> NotifyService::invokeNotifyDBusMethod(
+    [[maybe_unused]] sdbusplus::async::context& ctx,
+    [[maybe_unused]] const std::string& service,
+    [[maybe_unused]] const fs::path& modifiedDataPath)
+{
+    // TODO : Complete DBus notification method once INTERFACE and method name
+    // finalized
+    // Step 1 : Invoke getDbusObjectPath()
+    // Step 2 : Using the object path,interface and service, frame the DBus
+    // :method call
+    lg2::warning("DBus notification support is not available currently");
+
+    co_return;
+}
+
+sdbusplus::async::task<>
+    // NOLINTNEXTLINE
+    NotifyService::sendDBusNotification(sdbusplus::async::context& ctx,
+                                        std::vector<std::string> services,
+                                        fs::path modifiedDataPath)
+{
+    for (const auto& service : services)
+    {
+        // NOLINTNEXTLINE
+        co_await invokeNotifyDBusMethod(ctx, service, modifiedDataPath);
+    }
+
+    co_return;
+}
+
 sdbusplus::async::task<>
     // NOLINTNEXTLINE
     NotifyService::sendSystemDNotification(sdbusplus::async::context& ctx,
@@ -80,7 +160,13 @@ sdbusplus::async::task<> NotifyService::init(sdbusplus::async::context& ctx,
         file_operations::readfromFile(notifyFilePath);
     if (notifyfileData["NotifyInfo"]["Mode"] == "DBus")
     {
-        // TODO : Send DBUS notification
+        // Send DBUS notification
+        // NOLINTNEXTLINE
+        co_await sendDBusNotification(
+            ctx,
+            notifyfileData["NotifyInfo"]["NotifyServices"]
+                .get<std::vector<std::string>>(),
+            notifyfileData["ModifiedDataPath"]);
     }
     else if ((notifyfileData["NotifyInfo"]["Mode"] == "Systemd"))
     {

src/notify_service.hpp

@@ -33,6 +33,52 @@ class NotifyService
                   const fs::path& notifyFilePath);
 
   private:
+    /**
+     * @brief Get the Dbus Object Path object associated with the service
+     *        which implements the given interface.
+     *
+     * @param[in] ctx - The async context object
+     * @param[in] service - The DBus service name
+     * @param[in] interface - The DBus Interface name
+     *
+     * @return DBus Object path as sdbusplus::async::task<std::string>
+     */
+    static sdbusplus::async::task<std::string>
+        getDbusObjectPath(sdbusplus::async::context& ctx,
+                          const std::string& service,
+                          const std::string& interface);
+
+    /**
+     * @brief API to notify the requested services by triggering the DBus method
+     *        implemented at the service to be notified.
+     *
+     * @param[in] ctx - The async context object.
+     * @param[in] service - The DBus service name which need to be notified
+     *
+     * @return void
+     */
+    sdbusplus::async::task<>
+        invokeNotifyDBusMethod(sdbusplus::async::context& ctx,
+                               const std::string& service,
+                               const fs::path& modifiedDataPath);
+
+    /**
+     * @brief API to the initiate the DBus notification to all the
+     *.       configured services if the mode of notification is DBus.
+     *
+     * @param[in] ctx - The async context object.
+     * @param[in] services - The vector of DBus service name which need to be
+     *                       notified
+     * @param[in] modifiedDataPath - The root path of the modified path given in
+     *the request
+     *
+     * @return void
+     */
+    sdbusplus::async::task<>
+        sendDBusNotification(sdbusplus::async::context& ctx,
+                             std::vector<std::string> services,
+                             fs::path modifiedDataPath);
+
     /**
      *  @brief API to initiate the systemd notification to all the configured
      *         services if the mode of notification is systemd. It will trigger