Add CPP DeadlineMonitoring API

Author: pawelrutkaq

README.md

@@ -63,8 +63,8 @@ You can also use the config `--config=x86_64-linux` to build for linux.
 ## IDE support
 
 ### C++
-Use visual studio code with `clangd`. Make sure You don't have installed MS C++ Intellisense as this is likely to clash with `clangd`.
-Then you need to call `./scripts/generate_cpp_compile_commands.sh` to generate compilation DB for clangd and restart it in Vscode. Indexing shall work.
+Use Visual Studio Code with `clangd`. Make sure you don't have the MS C++ IntelliSense extension installed as this is likely to clash with `clangd`.
+Then you need to call `./scripts/generate_cpp_compile_commands.sh` to generate compilation DB for clangd and restart it in VS Code. Indexing shall work.
 
 ### Rust
 

src/health_monitoring_lib/BUILD

@@ -11,7 +11,8 @@
 # SPDX-License-Identifier: Apache-2.0
 # *******************************************************************************
 
-load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test", "rust_static_library")
+load("@score_baselibs//:bazel/unit_tests.bzl", "cc_gtest_unit_test", "cc_unit_test_suites_for_host_and_qnx")
 
 rust_library(
     name = "health_monitoring_lib",
@@ -26,10 +27,59 @@ rust_library(
     ],
 )
 
+
+rust_static_library(
+    name = "health_monitoring_lib_ffi",
+    srcs = glob(["src/**/*.rs"]),
+    crate_name = "health_monitoring_lib",
+    proc_macro_deps = [
+        "@score_baselibs_rust//src/testing_macros:score_testing_macros",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@score_baselibs_rust//src/log/score_log",
+    ],
+)
+
 rust_test(
     name = "tests",
     crate = ":health_monitoring_lib",
     deps = [
         "@score_baselibs_rust//src/log/stdout_logger",
     ],
 )
+
+cc_library(
+    name = "health_monitoring_lib_cc",
+    srcs = [
+        "cpp/deadline/deadline_monitor.cpp",
+        "cpp/health_monitor.cpp",
+        "cpp/common.cpp",
+        "cpp/ffi_helpers.h",
+        ],
+    hdrs = [
+        "cpp/include/score/hm/deadline/deadline_monitor.h",
+        "cpp/include/score/hm/common.h",
+        "cpp/include/score/hm/health_monitor.h"
+    
+    ],
+    visibility = ["//visibility:public"],
+    strip_include_prefix = "cpp/include",
+    deps = [
+        ":health_monitoring_lib_ffi",
+        "@score_baselibs//score/result",
+    ],
+    copts = [
+        "-Isrc/health_monitoring_lib/cpp",      # private include path
+    ],
+)
+
+cc_gtest_unit_test(
+    name = "cpp_tests",
+    srcs = [
+        "cpp/tests/health_monitor_test.cpp",
+    ],
+    deps = [
+        ":health_monitoring_lib_cc",
+    ],
+)

src/health_monitoring_lib/cpp/common.cpp

@@ -0,0 +1,69 @@
+#include <score/hm/common.h>
+
+namespace score::hm::internal
+{
+
+DroppableFFIHandle::DroppableFFIHandle(FFIHandle handle, DropFn drop_fn) : handle_(handle), drop_fn_(drop_fn) {}
+
+DroppableFFIHandle::DroppableFFIHandle(DroppableFFIHandle&& other) noexcept
+    : handle_(other.handle_), drop_fn_(other.drop_fn_)
+{
+    other.handle_ = nullptr;
+    other.drop_fn_ = nullptr;
+}
+
+DroppableFFIHandle& DroppableFFIHandle::operator=(DroppableFFIHandle&& other) noexcept
+{
+    if (this != &other)
+    {
+        // Clean up existing resources
+        if (drop_fn_)
+        {
+            drop_fn_(handle_);
+        }
+
+        // Move resources from other
+        handle_ = other.handle_;
+        drop_fn_ = other.drop_fn_;
+
+        // Nullify other's resources
+        other.handle_ = nullptr;
+        other.drop_fn_ = nullptr;
+    }
+    return *this;
+}
+
+::score::cpp::optional<FFIHandle> DroppableFFIHandle::as_rust_handle() const
+{
+    if (handle_ == nullptr)
+    {
+        return ::score::cpp::nullopt;
+    }
+
+    return handle_;
+}
+
+::score::cpp::optional<FFIHandle> DroppableFFIHandle::drop_by_rust()
+{
+    if (handle_ == nullptr)
+    {
+        return ::score::cpp::nullopt;
+    }
+
+    FFIHandle temp = handle_;
+    handle_ = nullptr;
+    drop_fn_ = nullptr;
+
+    return temp;
+}
+
+DroppableFFIHandle::~DroppableFFIHandle()
+{
+    // Clean up resources associated with the FFI handle
+    if (drop_fn_)
+    {
+        drop_fn_(handle_);
+    }
+}
+
+}  // namespace score::hm::internal

src/health_monitoring_lib/cpp/deadline/deadline_monitor.cpp

@@ -0,0 +1,118 @@
+#include "score/hm/deadline/deadline_monitor.h"
+#include "ffi_helpers.h"
+
+extern "C" {
+using namespace score::hm;
+using namespace score::hm::internal;
+using namespace score::hm::deadline;
+
+internal::FFIHandle deadline_monitor_builder_create();
+void deadline_monitor_builder_destroy(internal::FFIHandle handle);
+void deadline_monitor_builder_add_deadline(internal::FFIHandle handler,
+                                           const IdentTag* tag,
+                                           uint32_t min,
+                                           uint32_t max);
+int deadline_monitor_cpp_get_deadline(FFIHandle handler, const IdentTag* tag, FFIHandle* out);
+void deadline_monitor_cpp_destroy(FFIHandle handler);
+void deadline_destroy(FFIHandle deadline_handle);
+int deadline_start(FFIHandle deadline_handle);
+void deadline_stop(FFIHandle deadline_handle);
+}
+
+namespace score::hm::deadline
+{
+DeadlineMonitorBuilder::DeadlineMonitorBuilder()
+    : monitor_builder_handler_(deadline_monitor_builder_create(), &deadline_monitor_builder_destroy)
+{
+}
+
+DeadlineMonitorBuilder DeadlineMonitorBuilder::add_deadline(const IdentTag& tag, const TimeRange& range) &&
+{
+    auto handle = monitor_builder_handler_.as_rust_handle();
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
+
+    deadline_monitor_builder_add_deadline(handle.value(), &tag, range.min_as_u32(), range.max_as_u32());
+
+    return std::move(*this);
+}
+
+DeadlineMonitor::DeadlineMonitor(FFIHandle handle) : monitor_handle_(handle, &deadline_monitor_cpp_destroy) {}
+
+score::cpp::expected<Deadline, score::hm::Error> DeadlineMonitor::get_deadline(const IdentTag& tag)
+{
+    auto handle = monitor_handle_.as_rust_handle();
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
+
+    internal::FFIHandle ret = nullptr;
+    auto result = deadline_monitor_cpp_get_deadline(handle.value(), &tag, &ret);
+
+    if (result != kSuccess)
+    {
+        return score::cpp::unexpected(::score::hm::ffi::fromRustError(result));
+    }
+
+    return score::cpp::expected<Deadline, score::hm::Error>(Deadline{ret});
+}
+
+Deadline::Deadline(internal::FFIHandle handle) : deadline_handle_(handle, &deadline_destroy), has_handle_(false) {}
+
+Deadline::~Deadline()
+{
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(!has_handle_);
+}
+
+score::cpp::expected<DeadlineHandle, score::hm::Error> Deadline::start()
+{
+    if (has_handle_)
+    {
+        return score::cpp::unexpected(::score::hm::Error::WrongState);
+    }
+
+    auto handle = deadline_handle_.as_rust_handle();
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
+
+    auto result = deadline_start(handle.value());
+    if (result != kSuccess)
+    {
+        return score::cpp::unexpected(::score::hm::ffi::fromRustError(result));
+    }
+
+    has_handle_ = true;
+    return score::cpp::expected<DeadlineHandle, score::hm::Error>(DeadlineHandle{*this});
+}
+
+DeadlineHandle::DeadlineHandle(Deadline& deadline) : was_stopped_(false), deadline_(deadline) {}
+
+void DeadlineHandle::stop()
+{
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(deadline_.has_value());
+
+    if (!was_stopped_)
+    {
+        was_stopped_ = true;
+        auto handle = deadline_.value().get().deadline_handle_.as_rust_handle();
+        SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
+
+        deadline_stop(handle.value());
+    }
+}
+
+DeadlineHandle::DeadlineHandle(DeadlineHandle&& other)
+    : was_stopped_(other.was_stopped_), deadline_(std::move(other.deadline_))
+{
+    other.was_stopped_ = true;
+    other.deadline_ = ::score::cpp::optional<std::reference_wrapper<Deadline>>{};  // None
+}
+
+DeadlineHandle::~DeadlineHandle()
+{
+    if (!deadline_.has_value())
+    {
+        return;
+    }
+
+    stop();
+    deadline_.value().get().has_handle_ = false;
+}
+
+}  // namespace score::hm::deadline

src/health_monitoring_lib/cpp/ffi_helpers.h

@@ -0,0 +1,29 @@
+#ifndef SCORE_HM_FFI_HELPERS_HPP
+#define SCORE_HM_FFI_HELPERS_HPP
+
+namespace score::hm::ffi
+{
+
+inline Error fromRustError(int ffi_error_code)
+{
+    switch (ffi_error_code)
+    {
+        case 1:
+            return Error::NotFound;
+        case 2:
+            return Error::AlreadyExists;
+        case 3:
+            return Error::InvalidArgument;
+        case 4:
+            return Error::WrongState;
+        case 5:
+            return Error::Failed;
+        default:
+            assert(false && "Unknown FFI error code");
+            return Error::InvalidArgument;  // Fallback
+    }
+}
+
+}  // namespace score::hm::ffi
+
+#endif  // SCORE_HM_FFI_HELPERS_HPP

src/health_monitoring_lib/cpp/health_monitor.cpp

@@ -0,0 +1,87 @@
+#include "score/hm/health_monitor.h"
+
+extern "C" {
+using namespace score::hm;
+
+internal::FFIHandle health_monitor_builder_create();
+void health_monitor_builder_destroy(internal::FFIHandle handler);
+
+internal::FFIHandle health_monitor_builder_build(internal::FFIHandle health_monitor_builder_handle);
+void health_monitor_builder_add_deadline_monitor(internal::FFIHandle handle,
+                                                 const IdentTag* tag,
+                                                 internal::FFIHandle monitor_handle);
+
+internal::FFIHandle health_monitor_get_deadline_monitor(internal::FFIHandle health_monitor_handle, const IdentTag* tag);
+
+void health_monitor_destroy(internal::FFIHandle handler);
+}
+
+namespace score::hm
+{
+
+HealthMonitorBuilder::HealthMonitorBuilder()
+    : health_monitor_builder_handle_{health_monitor_builder_create(), &health_monitor_builder_destroy}
+{
+}
+
+HealthMonitorBuilder HealthMonitorBuilder::add_deadline_monitor(const IdentTag& tag,
+                                                                deadline::DeadlineMonitorBuilder&& monitor) &&
+{
+    auto monitor_handle = monitor.drop_by_rust();
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(monitor_handle.has_value());
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(health_monitor_builder_handle_.as_rust_handle().has_value());
+
+    health_monitor_builder_add_deadline_monitor(
+        health_monitor_builder_handle_.as_rust_handle().value(), &tag, monitor_handle.value());
+    return std::move(*this);
+}
+
+HealthMonitor HealthMonitorBuilder::build() &&
+{
+    auto handle = health_monitor_builder_handle_.drop_by_rust();
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
+
+    return HealthMonitor(health_monitor_builder_build(handle.value()));
+}
+
+HealthMonitor::HealthMonitor(internal::FFIHandle handle) : health_monitor_(handle)
+{
+    // Initialize health monitor
+}
+
+score::cpp::expected<deadline::DeadlineMonitor, Error> HealthMonitor::get_deadline_monitor(const IdentTag& tag)
+{
+    auto maybe_monitor = health_monitor_get_deadline_monitor(health_monitor_, &tag);
+
+    if (maybe_monitor != nullptr)
+    {
+
+        return score::cpp::expected<deadline::DeadlineMonitor, Error>(deadline::DeadlineMonitor{maybe_monitor});
+    }
+
+    return score::cpp::unexpected(Error::NotFound);
+}
+
+HealthMonitor::~HealthMonitor()
+{
+    if (health_monitor_ != nullptr)
+    {
+        health_monitor_destroy(health_monitor_);
+    }
+}
+
+HealthMonitor& HealthMonitor::operator=(HealthMonitor&& other)
+{
+    if (this != &other)
+    {
+        if (health_monitor_ != nullptr)
+        {
+            health_monitor_destroy(health_monitor_);
+        }
+        health_monitor_ = std::move(other.health_monitor_);
+        other.health_monitor_ = nullptr;
+    }
+    return *this;
+}
+
+}  // namespace score::hm