DataSync: Added signal-triggered watched paths logging utility

- Introduced a mechanism to handle SIGUSR1 signal for debugging
  purposes.
- Added support to read a list of paths from a predefined file and
  log, via journalctl, whether each path is currently being watched
  or not.
- On receiving the SIGUSR1 signal, the system logs all currently
  watched paths to a file for inspection.
- Helps in live debugging and verification of inotify watch status
  without restarting services.

Tested
- Added test cases.
- Verified on simics. Example JSON file generated:
```bash
$ kill -10 1156
$ cat /tmp/current_watched_paths.json
[
    "/var/lib",
    "/var/lib/phosphor-state-manager"
]
```

Change-Id: I251fcf15c5307a2ceca5e464d0bd2ba1b98f7974
Signed-off-by: Harsh Agarwal <[email protected]>

Author: harsh-agarwal1

src/data_watcher.cpp

@@ -18,6 +18,7 @@ DataWatcher::DataWatcher(sdbusplus::async::context& ctx, const int inotifyFlags,
     _fdioInstance(
         std::make_unique<sdbusplus::async::fdio>(ctx, _inotifyFileDescriptor()))
 {
+    getAllWatchers().push_back(this);
     createWatchers(_dataPathToWatch);
 }
 
@@ -32,6 +33,9 @@ DataWatcher::~DataWatcher()
             }
         });
     }
+    auto& instances = getAllWatchers();
+    instances.erase(std::remove(instances.begin(), instances.end(), this),
+                    instances.end());
 }
 
 int DataWatcher::inotifyInit() const

src/data_watcher.hpp

@@ -127,6 +127,29 @@ class DataWatcher
      */
     sdbusplus::async::task<DataOperations> onDataChange();
 
+    /**
+     * @brief API to get all the instances of the DataWatcher
+     *
+     * @returns std::vector<DataWatcher*> - A reference to the vector containing
+     * all instances of this class
+     */
+    static std::vector<DataWatcher*>& getAllWatchers()
+    {
+        static std::vector<DataWatcher*> instances;
+        return instances;
+    }
+
+    /**
+     * @brief API to get the file descriptor of the inotify instance
+     *
+     * @returns std::map<WD, fs::path>& - A reference to the map of WD and their
+     * associated file paths.
+     */
+    const std::map<WD, fs::path>& getWatchDescriptors() const
+    {
+        return _watchDescriptors;
+    }
+
   private:
     /**
      * @brief inotify flags

src/manager.cpp

@@ -7,6 +7,7 @@
 #include <nlohmann/json.hpp>
 #include <phosphor-logging/lg2.hpp>
 
+#include <csignal>
 #include <cstdlib>
 #include <exception>
 #include <fstream>
@@ -46,9 +47,59 @@ sdbusplus::async::task<> Manager::init()
         co_await startFullSync();
     }
 
+    std::signal(SIGUSR1, logSignalHandler);
     co_return co_await startSyncEvents();
 }
 
+std::unordered_set<std::string> Manager::collectAllWatchedPaths()
+{
+    std::unordered_set<std::string> watchedPaths;
+    for (const auto* watcher : watch::inotify::DataWatcher::getAllWatchers())
+    {
+        std::ranges::transform(
+            watcher->getWatchDescriptors(),
+            std::inserter(watchedPaths, watchedPaths.end()),
+            [](const auto& wdPathPair) { return wdPathPair.second.string(); });
+    }
+    return watchedPaths;
+}
+
+void Manager::logSignalHandler(int signal)
+{
+    lg2::info("Received signal: {SIGNAL}", "SIGNAL", signal);
+    std::unordered_set<std::string> watchedPaths = collectAllWatchedPaths();
+
+    std::string checkForWatchedPaths = "/tmp/check_watched_paths.txt";
+    if (std::ifstream infile{checkForWatchedPaths}; infile)
+    {
+        for (std::string line; std::getline(infile, line);)
+        {
+            std::string_view status =
+                watchedPaths.contains(line) ? "Watching" : "Not Watching";
+            lg2::info("{STATUS} path: {PATH}", "STATUS", status, "PATH", line);
+        }
+    }
+    else
+    {
+        lg2::info("Failed to open {FILE}", "FILE", checkForWatchedPaths);
+    }
+
+    // write all the paths to a file
+    try
+    {
+        std::string storeWatchedPath = "/tmp/current_watched_paths.json";
+        data_sync::persist::util::writeFile(nlohmann::json(watchedPaths),
+                                            storeWatchedPath);
+        lg2::info("Wrote all watched paths to file: {FILE}", "FILE",
+                  storeWatchedPath);
+    }
+    catch (const std::exception& e)
+    {
+        lg2::error("Error writing all watched paths to file: {ERROR}", "ERROR",
+                   e);
+    }
+}
+
 // NOLINTNEXTLINE
 sdbusplus::async::task<> Manager::parseConfiguration()
 {

src/manager.hpp

@@ -9,6 +9,7 @@
 
 #include <filesystem>
 #include <ranges>
+#include <unordered_set>
 #include <vector>
 
 namespace data_sync
@@ -201,6 +202,23 @@ class Manager
      */
     bool isSyncEligible(const config::DataSyncConfig& dataSyncCfg);
 
+    /**
+     * @brief A helper function to handle logging when a SIGUSR1 signal is
+     * received.
+     *
+     * @param[in] signal - The signal value that triggered the handler.
+     */
+    static void logSignalHandler(int signal);
+
+    /**
+     * @brief A helper API to collect all the paths currently being watched for
+     * immediate sync.
+     *
+     * @returns std::unordered_set<std::string> - A set containing all the paths
+     * being watched.
+     */
+    static std::unordered_set<std::string> collectAllWatchedPaths();
+
     /**
      * @brief The async context object used to perform operations asynchronously
      *        as required.

test/manager_test.cpp

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 #include "manager_test.hpp"
 
+#include <csignal>
+
 std::filesystem::path ManagerTest::dataSyncCfgDir;
 std::filesystem::path ManagerTest::tmpDataSyncDataDir;
 nlohmann::json ManagerTest::commonJsonData;
@@ -204,3 +206,117 @@ TEST_F(ManagerTest, testDBusDataPersistency)
 
     ctx.run();
 }
+
+TEST_F(ManagerTest, testSignalReceiverLogic)
+{
+    using namespace std::literals;
+    namespace ed = data_sync::ext_data;
+
+    std::unique_ptr<ed::ExternalDataIFaces> extDataIface =
+        std::make_unique<ed::MockExternalDataIFaces>();
+
+    ed::MockExternalDataIFaces* mockExtDataIfaces =
+        dynamic_cast<ed::MockExternalDataIFaces*>(extDataIface.get());
+
+    ON_CALL(*mockExtDataIfaces, fetchBMCRedundancyMgrProps())
+        // NOLINTNEXTLINE
+        .WillByDefault([&mockExtDataIfaces]() -> sdbusplus::async::task<> {
+        mockExtDataIfaces->setBMCRole(ed::BMCRole::Active);
+        mockExtDataIfaces->setBMCRedundancy(true);
+        co_return;
+    });
+
+    EXPECT_CALL(*mockExtDataIfaces, fetchSiblingBmcIP())
+        // NOLINTNEXTLINE
+        .WillRepeatedly([]() -> sdbusplus::async::task<> { co_return; });
+
+    EXPECT_CALL(*mockExtDataIfaces, fetchRbmcCredentials())
+        // NOLINTNEXTLINE
+        .WillRepeatedly([]() -> sdbusplus::async::task<> { co_return; });
+
+    nlohmann::json jsonData = {
+        {"Files",
+         {
+             {{"Path", ManagerTest::tmpDataSyncDataDir.string() + "/srcFile1"},
+              {"DestinationPath",
+               ManagerTest::tmpDataSyncDataDir.string() + "/destFile1"},
+              {"Description", "FullSync from Active to Passive bmc"},
+              {"SyncDirection", "Active2Passive"},
+              {"SyncType", "Immediate"}},
+             {{"Path", ManagerTest::tmpDataSyncDataDir.string() + "/srcFile2"},
+              {"DestinationPath",
+               ManagerTest::tmpDataSyncDataDir.string() + "/destFile2"},
+              {"Description", "FullSync from Active to Passive bmc"},
+              {"SyncDirection", "Active2Passive"},
+              {"SyncType", "Immediate"}},
+         }}};
+
+    std::string srcFile1{jsonData["Files"][0]["Path"]};
+    std::string srcFile2{jsonData["Files"][1]["Path"]};
+
+    std::string destFile1{jsonData["Files"][0]["DestinationPath"]};
+    std::string destFile2{jsonData["Files"][1]["DestinationPath"]};
+
+    writeConfig(jsonData);
+    sdbusplus::async::context ctx;
+
+    std::string data1{"Data written on the file1\n"};
+    std::string data2{"Data written on the file2\n"};
+
+    ManagerTest::writeData(srcFile1, data1);
+    ManagerTest::writeData(srcFile2, data2);
+
+    ASSERT_EQ(ManagerTest::readData(srcFile1), data1);
+    ASSERT_EQ(ManagerTest::readData(srcFile2), data2);
+
+    data_sync::Manager manager{ctx, std::move(extDataIface),
+                               ManagerTest::dataSyncCfgDir};
+
+    auto waitingForFullSyncToFinish =
+        // NOLINTNEXTLINE
+        [&](sdbusplus::async::context& ctx) -> sdbusplus::async::task<void> {
+        auto status = manager.getFullSyncStatus();
+
+        while (status != FullSyncStatus::FullSyncCompleted &&
+               status != FullSyncStatus::FullSyncFailed)
+        {
+            co_await sdbusplus::async::sleep_for(ctx,
+                                                 std::chrono::milliseconds(50));
+            status = manager.getFullSyncStatus();
+        }
+
+        EXPECT_EQ(status, FullSyncStatus::FullSyncCompleted)
+            << "FullSync status is not Completed!";
+
+        // Raising signal after full sync completes, so that sync events starts
+        // and the watchers are being created.
+        sdbusplus::async::sleep_for(ctx, 0.1s);
+        // Raising a signal to trigger the signal handler logic. This should
+        // write all the watched paths to a file.
+        std::raise(SIGUSR1); 
+
+        ctx.request_stop();
+
+        // Forcing to trigger inotify events so that all running immediate
+        // sync tasks will resume and stop since the context is requested to
+        // stop in the above.
+        ManagerTest::writeData(srcFile1, data1);
+        ManagerTest::writeData(srcFile2, data2);
+
+        // Reading the file where all the watched paths are written by signal
+        // handler logic.
+        auto watchersF =
+            ManagerTest::readData("/tmp/current_watched_paths.json");
+        auto parsed = nlohmann::json::parse(watchersF);
+        EXPECT_TRUE(parsed.is_array());
+        // Checking if the srcFile1 and srcFile2 are present in the parsed json
+        EXPECT_NE(std::find(parsed.begin(), parsed.end(), srcFile1),
+                  parsed.end());
+        EXPECT_NE(std::find(parsed.begin(), parsed.end(), srcFile2),
+                  parsed.end());
+        co_return;
+    };
+
+    ctx.spawn(waitingForFullSyncToFinish(ctx));
+    ctx.run();
+}