Implement timeout and scheduling logic

src/agent/instance_communicator/src/listener_wrapper.hpp

@@ -17,7 +17,7 @@ namespace instance_communicator
     public:
         explicit ListenerWrapper(const boost::asio::any_io_executor& executor);
 
-        bool CreateOrOpen([[maybe_unused]] const std::string& runPath, const std::size_t bufferSize) override;
+        bool CreateOrOpen(const std::string& runPath, const std::size_t bufferSize) override;
 
         boost::asio::awaitable<void> AsyncAccept(boost::system::error_code& ec) override;
 

src/common/CMakeLists.txt

@@ -13,6 +13,7 @@ add_subdirectory(linuxHelper)
 add_subdirectory(logger)
 add_subdirectory(mapWrapper)
 add_subdirectory(networkHelper)
+add_subdirectory(os_utils)
 add_subdirectory(pal)
 add_subdirectory(pipelineHelper)
 add_subdirectory(registryHelper)

src/common/cmdHelper/CMakeLists.txt

@@ -2,14 +2,16 @@ cmake_minimum_required(VERSION 3.22)
 
 project(cmd_helper)
 
+find_package(boost_process REQUIRED CONFIG)
+
 include(../../cmake/CommonSettings.cmake)
 set_common_settings()
 
 add_library(cmd_helper src/cmdHelper.cpp)
 
 target_include_directories(cmd_helper PUBLIC include)
 
-target_link_libraries(cmd_helper PRIVATE deleter_helper)
+target_link_libraries(cmd_helper PRIVATE Logger deleter_helper Boost::process)
 
 include(../../cmake/ConfigureTarget.cmake)
 configure_target(cmd_helper)

src/common/cmdHelper/include/cmdHelper.hpp

@@ -4,9 +4,26 @@
 
 namespace Utils
 {
+    struct ExecResult
+    {
+        std::string StdOut;
+        std::string StdErr;
+        int ExitCode;
+    };
+
     /// @brief Executes a command
     /// @param cmd command
     /// @param bufferSize buffer size in bytes
     /// @return command output
-    std::string Exec(const std::string& cmd, const size_t bufferSize = 128);
+    std::string PipeOpen(const std::string& cmd, const size_t bufferSize = 128);
+
+    /// @brief Executes a command and captures its output.
+    ///
+    /// Runs a command without using a shell, capturing both StdOut and StdErr.
+    /// The function waits for the process to finish before returning.
+    ///
+    /// @param cmd The command to execute (no shell features like piping or expansions).
+    /// @return A ExecResult containing the command's StdOut, StdErr, and ExitCode.
+    /// @throw boost::process::process_error if the command fails to start.
+    ExecResult Exec(const std::string& cmd);
 } // namespace Utils

src/common/cmdHelper/src/cmdHelper.cpp

@@ -1,27 +1,99 @@
-#include "cmdHelper.hpp"
+#include <cmdHelper.hpp>
+
+#include <fileSmartDeleter.hpp>
+#include <logger.hpp>
+
+#include <boost/process.hpp>
 
-#include "fileSmartDeleter.hpp"
 #include <cstdio>
 #include <memory>
-#include <string>
+#include <sstream>
+#include <stdexcept>
 #include <vector>
 
+namespace
+{
+    std::vector<std::string> TokenizeCommand(const std::string& command)
+    {
+        std::vector<std::string> result;
+        std::istringstream stream(command);
+        std::string token;
+        while (stream >> token)
+        {
+            result.push_back(token);
+        }
+
+        if (result.empty())
+        {
+            throw std::runtime_error("Empty command string");
+        }
+
+        return result;
+    }
+
+    std::string GetStreamOutput(std::istream& stream)
+    {
+        std::string line;
+        std::stringstream output;
+        while (std::getline(stream, line))
+        {
+            output << line << '\n';
+        }
+        return output.str();
+    }
+} // namespace
+
 namespace Utils
 {
-    std::string Exec(const std::string& cmd, const size_t bufferSize)
+    std::string PipeOpen(const std::string& cmd, const size_t bufferSize)
     {
         const std::unique_ptr<FILE, FileSmartDeleter> file {popen(cmd.c_str(), "r")};
         std::vector<char> buffer(bufferSize);
         std::string result;
 
         if (file)
         {
-            while (fgets(buffer.data(), static_cast<int>(bufferSize), file.get()))
+            while (fgets(buffer.data(), static_cast<int>(buffer.size()), file.get()))
             {
                 result += buffer.data();
             }
         }
 
         return result;
     }
+
+    ExecResult Exec(const std::string& cmd)
+    {
+        try
+        {
+            // Tokenize to separate the command and its arguments
+            const auto args = TokenizeCommand(cmd);
+            const auto exePath = boost::process::search_path(args[0]);
+            if (exePath.empty())
+            {
+                throw std::runtime_error("Executable not found in PATH: " + args[0]);
+            }
+
+            boost::process::ipstream stdoutStream;
+            boost::process::ipstream stderrStream;
+            const std::vector<std::string> execArgs(args.begin() + 1, args.end());
+
+            boost::process::child process(exePath,
+                                          boost::process::args = execArgs,
+                                          boost::process::std_out > stdoutStream,
+                                          boost::process::std_err > stderrStream);
+
+            const auto output = GetStreamOutput(stdoutStream);
+            const auto error = GetStreamOutput(stderrStream);
+            process.wait();
+
+            return {.StdOut = output, .StdErr = error, .ExitCode = process.exit_code()};
+        }
+        catch (const std::exception& e)
+        {
+            return {.StdOut = "", .StdErr = e.what(), .ExitCode = 1};
+        }
+
+        return {.StdOut = "", .StdErr = "", .ExitCode = 1};
+    }
 } // namespace Utils

src/common/cmdHelper/tests/cmdHelper_test.cpp

@@ -1,19 +1,52 @@
 #include "cmdHelper_test.hpp"
 #include "cmdHelper.hpp"
 
-void CmdUtilsTest::SetUp() {};
+#include <string>
 
-void CmdUtilsTest::TearDown() {};
 #ifdef WIN32
-TEST_F(CmdUtilsTest, CmdVersion)
+const std::string TEST_CMD = "ver";
+#else
+const std::string TEST_CMD = "uname";
+#endif
+
+TEST_F(CmdUtilsTest, PipeOpenCmd)
 {
-    const auto result {Utils::Exec("ver")};
+    const auto result {Utils::PipeOpen(TEST_CMD)};
     EXPECT_FALSE(result.empty());
 }
-#else
-TEST_F(CmdUtilsTest, CmdUname)
+
+TEST_F(CmdUtilsTest, ExecCmd)
 {
-    const auto result {Utils::Exec("uname")};
-    EXPECT_FALSE(result.empty());
+    const auto result {Utils::Exec(TEST_CMD)};
+    EXPECT_FALSE(result.StdOut.empty());
+    EXPECT_TRUE(result.StdErr.empty());
+    EXPECT_EQ(result.ExitCode, 0);
+}
+
+TEST_F(CmdUtilsTest, ExecInvalidCmd)
+{
+    const auto result {Utils::Exec("invalid_command")};
+    EXPECT_TRUE(result.StdOut.empty());
+    EXPECT_FALSE(result.StdErr.empty());
+    EXPECT_NE(result.ExitCode, 0);
+}
+
+TEST_F(CmdUtilsTest, PipeOpenInvalidCmd)
+{
+    const auto result {Utils::PipeOpen("invalid_command")};
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(CmdUtilsTest, ExecEmptyCmd)
+{
+    const auto result {Utils::Exec("")};
+    EXPECT_TRUE(result.StdOut.empty());
+    EXPECT_FALSE(result.StdErr.empty());
+    EXPECT_NE(result.ExitCode, 0);
+}
+
+TEST_F(CmdUtilsTest, PipeOpenEmptyCmd)
+{
+    const auto result {Utils::PipeOpen("")};
+    EXPECT_TRUE(result.empty());
 }
-#endif

src/common/cmdHelper/tests/cmdHelper_test.hpp

@@ -7,7 +7,4 @@ class CmdUtilsTest : public ::testing::Test
 protected:
     CmdUtilsTest() = default;
     virtual ~CmdUtilsTest() = default;
-
-    void SetUp() override;
-    void TearDown() override;
 };

src/common/data_provider/src/sysInfoMac.cpp

@@ -274,10 +274,10 @@ nlohmann::json SysInfo::getOsInfo() const
     };
 
     MacOsParser parser;
-    parser.parseSwVersion(Utils::Exec("sw_vers"), ret);
-    parser.parseUname(Utils::Exec("uname -r"), ret);
+    parser.parseSwVersion(Utils::PipeOpen("sw_vers"), ret);
+    parser.parseUname(Utils::PipeOpen("uname -r"), ret);
 
-    if (!parser.parseSystemProfiler(Utils::Exec("system_profiler SPSoftwareDataType"), ret))
+    if (!parser.parseSystemProfiler(Utils::PipeOpen("system_profiler SPSoftwareDataType"), ret))
     {
         ret["os_name"] = "macOS";
     }

src/common/data_provider/src/sysInfoWin.cpp

@@ -512,7 +512,7 @@ static std::string GetSerialNumber()
     }
     else
     {
-        const auto rawData {Utils::Exec("wmic baseboard get SerialNumber")};
+        const auto rawData {Utils::PipeOpen("wmic baseboard get SerialNumber")};
         const auto pos {rawData.find("\r\n")};
 
         if (pos != std::string::npos)

src/common/data_provider/src/utilsWrapper.cpp

@@ -3,5 +3,5 @@
 
 std::string UtilsWrapper::exec(const std::string& cmd, const size_t bufferSize)
 {
-    return Utils::Exec(cmd, bufferSize);
+    return Utils::PipeOpen(cmd, bufferSize);
 }

src/common/linuxHelper/tests/linuxInfoHelper_test.cpp

@@ -10,19 +10,19 @@ TEST_F(LinuxInfoHelperTest, getBootTime)
 {
     const auto btimeNumFromFunc {Utils::getBootTime()};
 
-    const auto btimeStr {Utils::Exec("grep 'btime' /proc/stat | awk '{print $2}'")};
+    const auto btimeStr {Utils::PipeOpen("grep 'btime' /proc/stat | awk '{print $2}'")};
     const auto btimeNumFromProc {std::stoull(btimeStr)};
 
     EXPECT_FALSE(btimeNumFromFunc != btimeNumFromProc);
 }
 
 TEST_F(LinuxInfoHelperTest, timeTick2unixTime)
 {
-    const auto startTimeStr {Utils::Exec("awk '{print $22}' /proc/1/stat")};
+    const auto startTimeStr {Utils::PipeOpen("awk '{print $22}' /proc/1/stat")};
     const auto startTimeNum {std::stoul(startTimeStr)};
     const auto startTimeUnixFunc {Utils::timeTick2unixTime(startTimeNum)};
 
-    const auto startTimeUnixCmd {std::stoul(Utils::Exec("LC_ALL=C date -d \"`ps -o lstart -p 1|tail -n 1`\" +%s"))};
+    const auto startTimeUnixCmd {std::stoul(Utils::PipeOpen("LC_ALL=C date -d \"`ps -o lstart -p 1|tail -n 1`\" +%s"))};
 
     EXPECT_FALSE(startTimeUnixFunc != startTimeUnixCmd);
 }

src/common/os_utils/CMakeLists.txt

@@ -1 +1,19 @@
+cmake_minimum_required(VERSION 3.22)
 
+project(OsUtils)
+
+include(../../cmake/CommonSettings.cmake)
+set_common_settings()
+
+add_library(OsUtils $<$<NOT:$<PLATFORM_ID:Windows>>:src/os_utils_unix.cpp>
+                    $<$<PLATFORM_ID:Windows>:src/os_utils_win.cpp>)
+target_include_directories(OsUtils PUBLIC include PRIVATE src)
+target_link_libraries(OsUtils PUBLIC FilesystemWrapper PRIVATE Logger deleter_helper)
+
+include(../../cmake/ConfigureTarget.cmake)
+configure_target(OsUtils)
+
+if(BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif()

src/common/os_utils/include/ios_utils.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace os_utils
+{
+    class IOsUtils
+    {
+    public:
+        /// @brief Virtual destructor for IOsUtils.
+        /// @note Ensures that any derived classes with their own resources are correctly cleaned up.
+        virtual ~IOsUtils() = default;
+
+        /// @brief Get the list of all running processes.
+        /// @return A vector of strings containing the names of running processes. Empty if none or error found.
+        virtual std::vector<std::string> GetRunningProcesses() = 0;
+    };
+} // namespace os_utils

src/common/os_utils/include/os_utils.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <ios_utils.hpp>
+
+#include <string>
+#include <vector>
+
+namespace os_utils
+{
+    class OsUtils : public IOsUtils
+    {
+    public:
+        /// @brief Destructor for OsUtils.
+        ~OsUtils() = default;
+
+        /// @copydoc IOsUtils::GetRunningProcesses
+        std::vector<std::string> GetRunningProcesses() override;
+    };
+} // namespace os_utils