Refactor Monitor API to public Alive API

Cargo.toml

@@ -2,7 +2,7 @@
 resolver = "2"
 members = [
     "score/launch_manager/src/lifecycle_client/src/rust",
-    "score/launch_manager/src/daemon/src/alive_monitor/rust",
+    "score/launch_manager/src/alive/src/rust",
     "score/health_monitor/src",
     "examples/rust_supervised_app",
 ]
@@ -19,7 +19,7 @@ libc = "0.2.177"
 clap = { version = "4.5.49", features = ["derive"] }
 signal-hook = "0.3.18"
 
-monitor_rs = { path = "score/launch_manager/src/daemon/src/alive_monitor/rust" } # Temporary API
+alive_rs = { path = "score/launch_manager/src/alive/src/rust" } # Temporary API
 health_monitoring_lib = { path = "score/health_monitor/src" }
 score_log = { git = "https://github.com/eclipse-score/baselibs_rust.git", tag = "v0.1.1" }
 score_testing_macros = { git = "https://github.com/eclipse-score/baselibs_rust.git", tag = "v0.1.1" }

examples/cpp_supervised_app/BUILD

@@ -33,7 +33,6 @@ cc_binary(
     visibility = ["//visibility:public"],
     deps = [
         "//score/health_monitor:health_monitoring_cc",
-        "//score/launch_manager:alive_cc",
         "//score/launch_manager:lifecycle_cc",
         "@score_baselibs_rust//src/log/stdout_logger_cpp_init",
     ],

examples/rust_supervised_app/Cargo.toml

@@ -12,7 +12,7 @@ clap = { workspace = true }
 libc = { workspace = true }
 signal-hook = { workspace = true }
 lifecycle_client_rs = { path = "../../score/launch_manager/src/lifecycle_client/src/rust" }
-monitor_rs = { path = "../../score/launch_manager/src/daemon/src/alive_monitor/rust" }
+alive_rs = { path = "../../score/launch_manager/src/alive/src/rust" }
 health_monitoring_lib.workspace = true
 score_log.workspace = true
 stdout_logger.workspace = true

score/health_monitor/src/Cargo.toml

@@ -18,7 +18,7 @@ thread.workspace = true
 score_log.workspace = true
 score_testing_macros.workspace = true
 containers.workspace = true
-monitor_rs = { workspace = true, optional = true }
+alive_rs = { workspace = true, optional = true }
 
 [dev-dependencies]
 stdout_logger.workspace = true
@@ -27,5 +27,5 @@ stdout_logger.workspace = true
 loom = { version = "0.7.2", features = ["checkpoint"] }
 
 [features]
-default = ["monitor_rs"]
+default = ["alive_rs"]
 stub_supervisor_api_client = []

score/health_monitor/src/rust/supervisor_api_client/score_supervisor_api_client.rs

@@ -15,10 +15,9 @@
 
 use crate::log::debug;
 use crate::supervisor_api_client::SupervisorAPIClient;
-use crate::worker::Checks;
 
 pub struct ScoreSupervisorAPIClient {
-    supervisor_link: monitor_rs::Monitor<Checks>,
+    supervisor_link: alive_rs::Alive,
 }
 
 unsafe impl Send for ScoreSupervisorAPIClient {} // Just assuming it's safe to send across threads, this is a temporary solution
@@ -28,13 +27,13 @@ impl ScoreSupervisorAPIClient {
         let value = std::env::var("IDENTIFIER").expect("IDENTIFIER env not set");
         debug!("ScoreSupervisorAPIClient: Creating with IDENTIFIER={}", value);
         // This is only temporary usage so unwrap is fine here.
-        let supervisor_link = monitor_rs::Monitor::<Checks>::new(&value).expect("Failed to create supervisor_link");
+        let supervisor_link = alive_rs::Alive::new(&value).expect("Failed to create supervisor_link");
         Self { supervisor_link }
     }
 }
 
 impl SupervisorAPIClient for ScoreSupervisorAPIClient {
     fn notify_alive(&self) {
-        self.supervisor_link.report_checkpoint(Checks::WorkerCheckpoint);
+        self.supervisor_link.report_alive();
     }
 }

score/launch_manager/BUILD

@@ -21,12 +21,12 @@ alias(
 
 alias(
     name = "alive_cc",
-    actual = "//score/launch_manager/src/daemon/src/alive_monitor:am_shared_lib",
+    actual = "//score/launch_manager/src/alive:alive",
 )
 
 alias(
     name = "alive_rust",
-    actual = "//score/launch_manager/src/daemon/src/alive_monitor/rust:monitor_rs",
+    actual = "//score/launch_manager/src/alive/src/rust:alive_rs",
 )
 
 alias(

score/launch_manager/src/alive/BUILD

@@ -0,0 +1,30 @@
+# *******************************************************************************
+# Copyright (c) 2026 Contributors to the Eclipse Foundation
+#
+# See the NOTICE file(s) distributed with this work for additional
+# information regarding copyright ownership.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Apache License Version 2.0 which is available at
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# SPDX-License-Identifier: Apache-2.0
+# *******************************************************************************
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "alive",
+    srcs = [
+        "src/alive.cpp",
+    ],
+    hdrs = [
+        "src/alive.h",
+    ],
+    include_prefix = "score/mw/lifecycle",
+    strip_include_prefix = "/score/launch_manager/src/alive/src",
+    visibility = ["//score:__subpackages__"],
+    deps = [
+        "//score/launch_manager/src/alive/src/details:alive_impl",
+        "@score_baselibs//score/language/futurecpp",
+    ],
+)

score/launch_manager/src/alive/src/alive.cpp

@@ -0,0 +1,89 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#include "score/mw/lifecycle/alive.h"
+#include "score/mw/launch_manager/alive_monitor/details/AliveImpl.h"
+
+#include <utility>
+#include <cassert>
+
+// The public API is only sending alive notification. No need to support different checkpoints.
+static constexpr std::uint32_t kDefaultCheckpointId{1U};
+
+namespace score::mw::lifecycle
+{
+
+Alive::Alive(const std::string_view& instance) noexcept(false) :
+    aliveImplPtr(std::make_unique<AliveImpl>(instance))
+{
+}
+
+Alive::Alive(Alive&& se) noexcept = default;
+
+Alive& Alive::operator=(Alive&& se) noexcept = default;
+
+Alive::~Alive() noexcept = default;
+
+void Alive::ReportAlive() const noexcept
+{
+    if (aliveImplPtr.get() != nullptr)
+    {
+        aliveImplPtr->ReportCheckpoint(kDefaultCheckpointId);
+    }
+}
+
+void Alive::ReportFailure() const noexcept
+{
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION_PRD_MESSAGE(false, "Alive::ReportFailure() is not yet implemented");
+}
+
+}  // namespace score::mw::lifecycle
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void* score_lcm_alive_initialize(const char* instanceSpecifier) noexcept {
+    if(instanceSpecifier == nullptr) {
+        return nullptr;
+    }
+
+    try {
+        auto* alivePtr = new score::mw::lifecycle::Alive(instanceSpecifier);
+        return static_cast<void*>(alivePtr);
+    } catch (...) {
+        return nullptr;
+    }
+}
+
+void score_lcm_alive_deinitialize(void* instance) noexcept {
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(instance != nullptr);
+    auto* alivePtr = static_cast<score::mw::lifecycle::Alive*>(instance);
+    delete alivePtr;
+}
+
+void score_lcm_alive_report_alive(void* instance) noexcept {
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(instance != nullptr);
+    static_cast<score::mw::lifecycle::Alive*>(instance)->ReportAlive();
+}
+
+void score_lcm_alive_report_failure(void* instance) noexcept {
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(instance != nullptr);
+    static_cast<score::mw::lifecycle::Alive*>(instance)->ReportFailure();
+}
+
+
+#ifdef __cplusplus
+}
+#endif

score/launch_manager/src/alive/src/alive.h

@@ -0,0 +1,76 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef SCORE_LCM_ALIVE_H_
+#define SCORE_LCM_ALIVE_H_
+
+#include <cstdint>
+#include <memory>
+#include <string_view>
+
+namespace score::mw::lifecycle
+{
+
+// Forward declaration
+class AliveImpl;
+
+/// @brief Alive API for reporting alive notifications to the launch manager.
+/// An alive notification indicates that the component is still active and functioning correctly.
+/// The launch manager is configured with an expected alive notification interval, 
+/// and if it does not receive an alive notification within that interval, 
+/// it executes the configured recovery action.
+///
+/// Each process may only use a single Alive instance.
+class Alive
+{
+public:
+    /// @brief Creation of an Alive.
+    /// @param [in] instance  Instance specifier (currently unused)
+    /// @throws std::runtime_error if the configured IPC channel to connect to launch manager is not existing
+    /// @throws std::bad_alloc in case of insufficient memory
+    explicit Alive(const std::string_view& instance) noexcept(false);
+
+    /// @brief The copy constructor for Alive shall not be used.
+    Alive(const Alive& se) = delete;
+
+    /// @brief Move constructor for Alive
+    /// @param [in,out] se  The Alive object to be moved
+    Alive(Alive&& se) noexcept;
+
+    /// @brief The copy assignment operator for Alive shall not be used.
+    Alive& operator=(const Alive& se) = delete;
+
+    /// @brief Move assignment operator for Alive
+    /// @param [in,out] se  The Alive object to be moved
+    /// @return The moved Alive object
+    Alive& operator=(Alive&& se) noexcept;
+
+    /// @brief Destructor of an Alive
+    virtual ~Alive() noexcept;
+
+    /// @brief Reports an alive notification
+    /// @remark Thread safety: This method is NOT thread safe.
+    void ReportAlive() const noexcept;
+
+    /// @brief Report a direct failure
+    /// @remark Thread safety: This method is NOT thread safe.
+    /// @note Not Implemented. This method currently does nothing.
+    void ReportFailure() const noexcept;
+
+private:
+    /// @brief Unique pointer to implementation class of Alive
+    std::unique_ptr<AliveImpl> aliveImplPtr;
+};
+
+}  // namespace score::mw::lifecycle
+#endif  // SCORE_LCM_ALIVE_H_

score/launch_manager/src/daemon/src/alive_monitor/details/MonitorImpl.cpp → score/launch_manager/src/alive/src/details/AliveImpl.cpp

@@ -11,7 +11,7 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 
-#include "score/mw/launch_manager/alive_monitor/details/MonitorImpl.h"
+#include "score/mw/launch_manager/alive_monitor/details/AliveImpl.h"
 
 #include <unistd.h>
 
@@ -22,7 +22,7 @@
 namespace score::mw::lifecycle
 {
 
-MonitorImpl::MonitorImpl(const std::string_view& f_instanceSpecifier_r,
+AliveImpl::AliveImpl(const std::string_view& f_instanceSpecifier_r,
                          std::unique_ptr<CheckpointIpcClient> f_ipcClient) noexcept(false)
     : k_instanceSpecifierPath(f_instanceSpecifier_r),
       ipcClient(std::move(f_ipcClient)),
@@ -33,17 +33,17 @@ MonitorImpl::MonitorImpl(const std::string_view& f_instanceSpecifier_r,
     connectToPhmDaemon();
 }
 
-void MonitorImpl::ReportCheckpoint(Checkpoint f_checkpointId) const noexcept(true)
+void AliveImpl::ReportCheckpoint(std::uint32_t f_checkpointId) const noexcept(true)
 {
     (void)ipcClient->sendEmplace(score::lcm::saf::timers::OsClock::getMonotonicSystemClock(), f_checkpointId);
 }
 
-void MonitorImpl::connectToPhmDaemon(void) noexcept(false)
+void AliveImpl::connectToPhmDaemon(void) noexcept(false)
 {
     const auto ipc_path_res = readInterfacePath();
     if (ipc_path_res == std::nullopt)
     {
-        logger_r.LogError() << "Failed to load interface path for Monitor (" << k_instanceSpecifierPath << ")";
+        logger_r.LogError() << "Failed to load interface path for Alive instance (" << k_instanceSpecifierPath << ")";
         throw std::runtime_error("Failed to get interface path");
     }
     CheckpointIpcClient::EIpcInitResult initResult{ipcClient->init(ipc_path_res.value())};
@@ -55,13 +55,13 @@ void MonitorImpl::connectToPhmDaemon(void) noexcept(false)
     {
         const uid_t uid{geteuid()};
         logger_r.LogError() << "Connection to PHM daemon failed (permission denied for effective uid" << uid
-                            << "), for the Monitor (" << k_instanceSpecifierPath << ")";
+                            << "), for the Alive instance (" << k_instanceSpecifierPath << ")";
         return;
     }
-    logger_r.LogError() << "Connection to PHM daemon failed, for the Monitor (" << k_instanceSpecifierPath << ")";
+    logger_r.LogError() << "Connection to PHM daemon failed, for the Alive instance (" << k_instanceSpecifierPath << ")";
 }
 
-std::optional<std::string_view> MonitorImpl::readInterfacePath() noexcept
+std::optional<std::string_view> AliveImpl::readInterfacePath() noexcept
 {
     const char* if_path{getenv("LCM_ALIVE_INTERFACE_PATH")};
     if (if_path == nullptr || if_path[0] == '\0')