Merge pull request #55 from Valeo-S-CORE-Organization/Implement_report_running_state

Implementing report running state in lifecycle manager

Author: ramceb

examples/cpp_lifecycle_app/BUILD

@@ -25,6 +25,6 @@ cc_binary(
     }),
     visibility = ["//visibility:public"],
     deps = [
-        "//src/launch_manager_daemon/lifecycle_client_lib:lifecycle_client",
+        "//src/lifecycle_client_lib",
     ],
 )

examples/cpp_lifecycle_app/main.cpp

@@ -13,19 +13,19 @@
 
 #include <optional>
 #include <unistd.h>
-#include <csignal>
-#include <atomic>
-#include <thread>
 #include <iostream>
 #include <ctime>
 #include <string>
+#include <chrono>
+#include <vector>
 
 #ifdef __linux__
     #include <linux/prctl.h>
     #include <sys/prctl.h>
 #endif
 
-#include "score/lcm/lifecycle_client.h"
+#include "src/lifecycle_client_lib/include/application.h"
+#include "src/lifecycle_client_lib/include/runapplication.h"
 
 /// @brief CLI configuration options for the not_supervised_application process
 struct Config
@@ -53,18 +53,15 @@ std::optional<Config> parseOptions(int argc, char *const *argv) noexcept
         switch (static_cast<char>(c))
         {
         case 'r':
-            // response time
             config.responseTimeInMs = std::stoi(optarg);
             break;
 
         case 'c':
-            // crash time
             config.crashRequested = true;
             config.crashTimeInMs = std::stoi(optarg);
             break;
 
         case 's':
-            // start-up failure
             config.failToStart = true;
             break;
 
@@ -88,93 +85,128 @@ std::optional<Config> parseOptions(int argc, char *const *argv) noexcept
     return config;
 }
 
-std::atomic<bool> exitRequested{false};
-
-void signalHandler(int)
+void set_process_name()
 {
-    exitRequested = true;
-}
-
-void set_process_name() {
     const char* identifier = getenv("PROCESSIDENTIFIER");
-    if(identifier != nullptr) {
+    if (identifier != nullptr)
+    {
     #ifdef __QNXNTO__
-            if (pthread_setname_np(pthread_self(), identifier) != 0) {
-                std::cerr << "Failed to set QNX thread name" << std::endl;
-            }
+        if (pthread_setname_np(pthread_self(), identifier) != 0)
+        {
+            std::cerr << "Failed to set QNX thread name" << std::endl;
+        }
     #elif defined(__linux__)
-            if (prctl(PR_SET_NAME, identifier) < 0) {
-                std::cerr << "Failed to set process name to " << identifier << std::endl;
-            }
+        if (prctl(PR_SET_NAME, identifier) < 0)
+        {
+            std::cerr << "Failed to set process name to " << identifier << std::endl;
+        }
     #endif
     }
 }
 
-int main(int argc, char **argv)
+class LifecycleApp final : public score::mw::lifecycle::Application
 {
-    set_process_name();
+public:
+    std::int32_t Initialize(const score::mw::lifecycle::ApplicationContext& appCtx) override
+    {
+        set_process_name();
 
-    signal(SIGINT, signalHandler);
-    signal(SIGTERM, signalHandler);
+        // Build a classic argv for getopt() from ApplicationContext arguments
+        const auto& args = appCtx.get_arguments();
+        m_argvStorage.clear();
+        m_argvStorage.reserve(args.size() + 2);
 
-    const auto config = parseOptions(argc, argv);
-    if (!config)
-    {
-        return EXIT_FAILURE;
-    }
+        // Ensure argv[0] exists (getopt expects it)
+        if (args.empty())
+        {
+            m_argvStorage.push_back(const_cast<char*>("LifecycleApp"));
+        }
+        else
+        {
+            for (const auto& s : args)
+            {
+                // NOTE: relies on the underlying storage staying alive during Initialize().
+                m_argvStorage.push_back(const_cast<char*>(s.data()));
+            }
+        }
 
-    std::chrono::time_point<std::chrono::steady_clock> startTime = std::chrono::steady_clock::now();
-    std::chrono::duration<double, std::milli> runTime;
+        m_argvStorage.push_back(nullptr);
 
-    if (true == config->failToStart)
-    {
-        return EXIT_FAILURE;
-    }
+        optind = 1;
 
-    score::lcm::LifecycleClient{}.ReportExecutionState(score::lcm::ExecutionState::kRunning);
+        const int argcLocal = static_cast<int>(m_argvStorage.size() - 1);
+        const auto config = parseOptions(argcLocal, m_argvStorage.data());
+        if (!config)
+        {
+            return EXIT_FAILURE;
+        }
 
-    timespec req{
-        static_cast<time_t>(config->responseTimeInMs / 1000),
-        static_cast<long>((config->responseTimeInMs % 1000) * 1000000L)
-    };
-    auto timeLastVerboseLog = std::chrono::steady_clock::now();
-    while (!exitRequested)
-    {
-        if (true == config->crashRequested)
+        m_config = *config;
+
+        if (true == m_config.failToStart)
         {
-            runTime = std::chrono::steady_clock::now() - startTime;
+            return EXIT_FAILURE;
+        }
 
-            int timeTillCrash = static_cast<int>(config->crashTimeInMs - runTime.count());
+        return 0;
+    }
 
-            if (timeTillCrash < config->responseTimeInMs)
+    std::int32_t Run(const score::cpp::stop_token& stopToken) override
+    {
+        std::chrono::time_point<std::chrono::steady_clock> startTime = std::chrono::steady_clock::now();
+        std::chrono::duration<double, std::milli> runTime;
+
+        timespec req{
+            static_cast<time_t>(m_config.responseTimeInMs / 1000),
+            static_cast<long>((m_config.responseTimeInMs % 1000) * 1000000L)
+        };
+
+        auto timeLastVerboseLog = std::chrono::steady_clock::now();
+
+        while (!stopToken.stop_requested())
+        {
+            if (true == m_config.crashRequested)
             {
-                // OK we need a shorter sleep now
-                if (timeTillCrash > 0)
+                runTime = std::chrono::steady_clock::now() - startTime;
+                int timeTillCrash = static_cast<int>(m_config.crashTimeInMs - runTime.count());
+
+                if (timeTillCrash < m_config.responseTimeInMs)
                 {
-                    timespec crash_req{
-                        static_cast<time_t>(timeTillCrash / 1000),
-                        static_cast<long>((timeTillCrash % 1000) * 1000000L)
-                    };
-                    nanosleep(&crash_req, nullptr);
+                    if (timeTillCrash > 0)
+                    {
+                        timespec crash_req{
+                            static_cast<time_t>(timeTillCrash / 1000),
+                            static_cast<long>((timeTillCrash % 1000) * 1000000L)
+                        };
+                        nanosleep(&crash_req, nullptr);
+                    }
+
+                    std::abort();
                 }
-
-                // let's crash...
-                std::abort();
             }
-        }
-
 
-        if(config->verbose) {
-            const auto now = std::chrono::steady_clock::now();
-            if(now - timeLastVerboseLog >= std::chrono::seconds(1)) {
-                std::cout << "LifecycleApp: " << "Running in verbose mode" << std::endl;
-                timeLastVerboseLog = now;
+            if (m_config.verbose)
+            {
+                const auto now = std::chrono::steady_clock::now();
+                if (now - timeLastVerboseLog >= std::chrono::seconds(1))
+                {
+                    std::cout << "LifecycleApp: Running in verbose mode" << std::endl;
+                    timeLastVerboseLog = now;
+                }
             }
+
+            nanosleep(&req, nullptr);
         }
 
-        nanosleep(&req, nullptr);
+        return EXIT_SUCCESS;
     }
 
-    // normal exit
-    return EXIT_SUCCESS;
+private:
+    Config m_config{};
+    std::vector<char*> m_argvStorage{};
+};
+
+int main(int argc, char** argv)
+{
+    return score::mw::lifecycle::run_application<LifecycleApp>(argc, argv);
 }

src/lifecycle_client_lib/BUILD

@@ -44,6 +44,7 @@ cc_library(
     }),
     visibility = ["//visibility:public"],
     deps = [
+        "//src/launch_manager_daemon/lifecycle_client_lib:lifecycle_client",
         "@score_baselibs//score/language/futurecpp",
         "@score_baselibs//score/memory:string_literal",
         "@score_baselibs//score/mw/log",
@@ -115,6 +116,7 @@ cc_library(
     tags = ["FUSA"],
     deps = [
         ":application",
+        "//src/launch_manager_daemon/lifecycle_client_lib:lifecycle_client",
         "@score_baselibs//score/mw/log",
         "@score_baselibs//score/os:stdlib",
         "@score_baselibs//score/os/utils:signal",

src/lifecycle_client_lib/include/lifecyclemanager.h

@@ -83,7 +83,7 @@ class LifeCycleManager
     /**
      * \brief Hook function for reporting running state.
      */
-    virtual void report_running() noexcept {};
+    virtual void report_running() noexcept ;
     /**
      * \brief Hook function for reporting shutdown state.
      */

src/lifecycle_client_lib/include/runapplication.h

@@ -68,7 +68,8 @@ template <typename ApplicationType, typename... Args>
 /* NOLINTNEXTLINE(modernize-avoid-c-arrays): array tolerated for command line arguments */
 std::int32_t run_application(const std::int32_t argc, const score::StringLiteral argv[], Args&&... args)
 {
-    return 0;
+    score::mw::lifecycle::Run<ApplicationType> runner(argc, argv);
+    return runner.AsPosixProcess(std::forward<Args>(args)...);
 }
 
 }  // namespace lifecycle

src/lifecycle_client_lib/src/lifecyclemanager.cpp

@@ -15,7 +15,7 @@
 
 #include "score/os/errno.h"
 #include <cstdlib>
-
+#include "score/lcm/lifecycle_client.h"
 #include "score/mw/log/logging.h"
 #include "score/os/stdlib_impl.h"
 
@@ -166,3 +166,13 @@ void score::mw::lifecycle::LifeCycleManager::handle_signal()
         /* KW_SUPPRESS_END:MISRA.STDLIB.ABORT,MISRA.USE.EXPANSION */
     }
 }
+
+void score::mw::lifecycle::LifeCycleManager::report_running() noexcept
+{
+    mw::log::LogInfo() << "Reporting kRunning to Launch Manager";
+    const auto result = score::lcm::LifecycleClient{}.ReportExecutionState(score::lcm::ExecutionState::kRunning);
+    if (!result.has_value())
+    {
+        mw::log::LogError() << "Failed to report kRunning to Launch Manager: " << result.error().Message();
+    }
+}