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 user defined file
  `/tmp/data_sync_check_watched_paths.txt` and log to file
  `/tmp/data_sync_check_output.txt`, whether each path is currently
  being watched or not.
- To trigger send the SIGUSR1 signal to `phosphor-rbmc-data-sync-mgr`
- On receiving the SIGUSR1 signal, if user defined file is absent,
  then the system logs all currently watched paths to
  `/tmp/data_sync_current_watched_paths.json`.
- Helps in live debugging and verification of inotify watch status
  without restarting services.

Tested
- Added test cases.
- Verified on simics.
If `/tmp/data_sync_check_watched_paths.txt` present,
Example output file generated:
```bash
$ kill -10 1156
$ cat data_sync_check_output.txt
Individual user entered paths results:
Watching path: /var/lib
Not Watching path: ntest
```
If `/tmp/data_sync_check_watched_paths.txt` absent,
Example JSON file generated:
```bash
$ kill -10 1156
$ cat /tmp/data_sync_current_watched_paths.json
[
    "/var/lib",
    "/var/lib/phosphor-state-manager"
]
```

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

Author: harsh-agarwal1

README.md

@@ -10,3 +10,24 @@ BMC applications.
 meson setup builddir
 meson compile -C builddir
 ```
+
+### Signal-Triggered Watched Paths Logging (Debug Utility)
+
+Inspect watched paths using the `SIGUSR1` signal. This feature is helpful for
+verifying which paths are currently being monitored by the system.
+
+If you want to check if some particular paths are being monitored or not, create
+a file `/tmp/data_sync_check_watched_paths.txt` and enter the paths line by
+line. Then send the signal, you can see the output in
+`/tmp/data_sync_check_output.txt`.
+
+If the user input file is not present, then on receiving the signal, it will
+write all the currently monitored path to
+`/tmp/data_sync_current_watched_paths.json`.
+
+To trigger the utility, send a `SIGUSR1` signal to the
+`phosphor-rbmc-data-sync-mgr` process:
+
+```bash
+kill -10 <pid_of_phosphor-rbmc-data-sync-mgr>
+```

src/data_watcher.cpp

@@ -19,6 +19,8 @@ DataWatcher::DataWatcher(sdbusplus::async::context& ctx, const int inotifyFlags,
         std::make_unique<sdbusplus::async::fdio>(ctx, _inotifyFileDescriptor()))
 {
     createWatchers(_dataPathToWatch);
+    std::lock_guard<std::mutex> lock(getMutex());
+    getAllWatchers().push_back(this);
 }
 
 DataWatcher::~DataWatcher()
@@ -32,6 +34,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

@@ -9,6 +9,7 @@
 
 #include <filesystem>
 #include <map>
+#include <mutex>
 
 namespace data_sync::watch::inotify
 {
@@ -127,6 +128,42 @@ 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 reference to the static mutex to guard
+     * concurrent access to shared data (i.e., the vector of DataWatcher
+     * instances)
+     *
+     * @returns std::mutex& - A reference to the static mutex
+     */
+    static std::mutex& getMutex()
+    {
+        static std::mutex mtx;
+        return mtx;
+    }
+
+    /**
+     * @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,76 @@ 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::saveWatchedPathsToFile()
+{
+    std::string storeWatchedPath = "/tmp/data_sync_current_watched_paths.json";
+    try
+    {
+        data_sync::persist::util::writeFile(
+            nlohmann::json(collectAllWatchedPaths()), 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);
+    }
+}
+
+void Manager::watchedPathCheck(std::ifstream& infile)
+{
+    std::string outputFilePath = "/tmp/data_sync_check_output.txt";
+    std::unordered_set<std::string> watchedPaths = collectAllWatchedPaths();
+    if (std::ofstream outfile(outputFilePath); outfile)
+    {
+        outfile << "Individual user entered paths results:\n";
+        for (std::string line; std::getline(infile, line);)
+        {
+            std::string_view status =
+                watchedPaths.contains(line) ? "Watching" : "Not Watching";
+            outfile << status << " path: " << line << '\n';
+        }
+    }
+    else
+    {
+        lg2::error("Failed to write to {FILE}", "FILE", outputFilePath);
+    }
+}
+
+void Manager::logSignalHandler(int signal)
+{
+    lg2::info("Received signal: {SIGNAL}", "SIGNAL", signal);
+    std::string checkForWatchedPaths = "/tmp/data_sync_check_watched_paths.txt";
+    if (std::ifstream infile{checkForWatchedPaths}; infile)
+    {
+        watchedPathCheck(infile);
+    }
+    else
+    {
+        lg2::info("Unable to open user input {FILE}, logging all watched paths",
+                  "FILE", checkForWatchedPaths);
+        saveWatchedPathsToFile();
+    }
+}
+
 // 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,39 @@ class Manager
      */
     bool isSyncEligible(const config::DataSyncConfig& dataSyncCfg);
 
+    /**
+     * @brief A helper function which saves all currently watched paths to a
+     * JSON file.
+     */
+    static void saveWatchedPathsToFile();
+
+    /**
+     * @brief A helper function which reads paths from the given input file
+     * stream and compares each path against currently watched paths, then
+     * writes the result for each path to `/tmp/data_sync_check_output.txt`.
+     *
+     * @param[in] infile - Input file stream containing one path per line to
+     * check.
+     */
+    static void watchedPathCheck(std::ifstream& infile);
+
+    /**
+     * @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;
@@ -208,3 +210,118 @@ 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() + "/destDir/"},
+              {"Description", "FullSync from Active to Passive bmc"},
+              {"SyncDirection", "Active2Passive"},
+              {"SyncType", "Immediate"}},
+             {{"Path", ManagerTest::tmpDataSyncDataDir.string() + "/srcFile2"},
+              {"DestinationPath",
+               ManagerTest::tmpDataSyncDataDir.string() + "/destDir/"},
+              {"Description", "FullSync from Active to Passive bmc"},
+              {"SyncDirection", "Active2Passive"},
+              {"SyncType", "Immediate"}},
+         }}};
+
+    fs::path srcFile1{jsonData["Files"][0]["Path"]};
+    fs::path srcFile2{jsonData["Files"][1]["Path"]};
+
+    fs::path destDir1{jsonData["Files"][0]["DestinationPath"]};
+    fs::path destDir2{jsonData["Files"][1]["DestinationPath"]};
+
+    writeConfig(jsonData);
+    std::filesystem::remove("/tmp/data_sync_check_watched_paths.txt");
+    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.
+        std::raise(SIGUSR1);
+        //  waiting to write all the watched paths to a file as per
+        // signal handler logic.
+        sdbusplus::async::sleep_for(ctx, 0.5s);
+
+        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/data_sync_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(watchersF.find(srcFile1), std::string::npos);
+        EXPECT_NE(watchersF.find(srcFile2), std::string::npos);
+        co_return;
+    };
+
+    ctx.spawn(waitingForFullSyncToFinish(ctx));
+    ctx.run();
+}