hmon: rework error handling in FFI

- Uniformly return `FFICode` in FFI functions.
- Unit tests for FFI functions in Rust.
- Rework comments for FFI functions.
- Move `crate::common::ffi` to `crate::ffi`.

Author: arkjedrz

src/health_monitoring_lib/BUILD

@@ -28,7 +28,6 @@ PROC_MACRO_DEPS = [
 CC_SOURCES = [
     "cpp/common.cpp",
     "cpp/deadline_monitor.cpp",
-    "cpp/ffi_helpers.h",
     "cpp/health_monitor.cpp",
 ]
 

src/health_monitoring_lib/cpp/common.cpp

@@ -11,10 +11,19 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 #include <score/hm/common.h>
+#include <cstdlib>
 
 namespace score::hm::internal
 {
 
+void abort_on_error(FFICode code)
+{
+    if (code != kSuccess)
+    {
+        std::abort();
+    }
+}
+
 DroppableFFIHandle::DroppableFFIHandle(FFIHandle handle, DropFn drop_fn) : handle_(handle), drop_fn_(drop_fn) {}
 
 DroppableFFIHandle::DroppableFFIHandle(DroppableFFIHandle&& other) noexcept

src/health_monitoring_lib/cpp/deadline_monitor.cpp

@@ -11,33 +11,47 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 #include "score/hm/deadline/deadline_monitor.h"
-#include "ffi_helpers.h"
 
+namespace
+{
 extern "C" {
 using namespace score::hm;
 using namespace score::hm::internal;
 using namespace score::hm::deadline;
 
-// Deadline monitoring Foreign Function Interface Declarations that are exported by Rust implementation library
-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);
+// Functions below must match functions defined in `crate::deadline::ffi`.
+
+FFICode deadline_monitor_builder_create(FFIHandle* deadline_monitor_builder_handle_out);
+FFICode deadline_monitor_builder_destroy(FFIHandle deadline_monitor_builder_handle);
+FFICode deadline_monitor_builder_add_deadline(FFIHandle deadline_monitor_builder_handle,
+                                              const IdentTag* deadline_tag,
+                                              uint32_t min_ms,
+                                              uint32_t max_ms);
+FFICode deadline_monitor_get_deadline(FFIHandle deadline_monitor_handle,
+                                      const IdentTag* deadline_tag,
+                                      FFIHandle* deadline_handle_out);
+FFICode deadline_monitor_destroy(FFIHandle deadline_monitor_handle);
+FFICode deadline_destroy(FFIHandle deadline_handle);
+FFICode deadline_start(FFIHandle deadline_handle);
+FFICode deadline_stop(FFIHandle deadline_handle);
+}
+
+FFIHandle deadline_monitor_builder_create_wrapper()
+{
+    FFIHandle handle{nullptr};
+    auto result{deadline_monitor_builder_create(&handle)};
+    abort_on_error(result);
+    return handle;
 }
 
+}  // namespace
+
 // C++ wrapper for Rust library - the API implementation obeys the Rust API semantics and it's invariants
 
 namespace score::hm::deadline
 {
 DeadlineMonitorBuilder::DeadlineMonitorBuilder()
-    : monitor_builder_handler_(deadline_monitor_builder_create(), &deadline_monitor_builder_destroy)
+    : monitor_builder_handler_{deadline_monitor_builder_create_wrapper(), &deadline_monitor_builder_destroy}
 {
 }
 
@@ -46,30 +60,30 @@ DeadlineMonitorBuilder DeadlineMonitorBuilder::add_deadline(const IdentTag& tag,
     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_ms(), range.max_ms());
+    auto result{deadline_monitor_builder_add_deadline(handle.value(), &tag, range.min_ms(), range.max_ms())};
+    abort_on_error(result);
 
     return std::move(*this);
 }
 
-DeadlineMonitor::DeadlineMonitor(FFIHandle handle) : monitor_handle_(handle, &deadline_monitor_cpp_destroy) {}
+DeadlineMonitor::DeadlineMonitor(FFIHandle handle) : monitor_handle_(handle, &deadline_monitor_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);
-
+    FFIHandle ret = nullptr;
+    auto result = deadline_monitor_get_deadline(handle.value(), &tag, &ret);
     if (result != kSuccess)
     {
-        return score::cpp::unexpected(::score::hm::ffi::fromRustError(result));
+        return score::cpp::unexpected(static_cast<Error>(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(FFIHandle handle) : deadline_handle_(handle, &deadline_destroy), has_handle_(false) {}
 
 Deadline::~Deadline()
 {
@@ -90,7 +104,7 @@ score::cpp::expected<DeadlineHandle, score::hm::Error> Deadline::start()
     auto result = deadline_start(handle.value());
     if (result != kSuccess)
     {
-        return score::cpp::unexpected(::score::hm::ffi::fromRustError(result));
+        return score::cpp::unexpected(static_cast<Error>(result));
     }
 
     has_handle_ = true;
@@ -109,7 +123,8 @@ void DeadlineHandle::stop()
         auto handle = deadline_.value().get().deadline_handle_.as_rust_handle();
         SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
 
-        deadline_stop(handle.value());
+        auto result{deadline_stop(handle.value())};
+        abort_on_error(result);
     }
 }
 

src/health_monitoring_lib/cpp/ffi_helpers.h

@@ -12,44 +12,62 @@
  ********************************************************************************/
 #include "score/hm/health_monitor.h"
 
+namespace
+{
 extern "C" {
 using namespace score::hm;
+using namespace score::hm::internal;
+using namespace score::hm::deadline;
+
+// Functions below must match functions defined in `crate::ffi`.
+
+FFICode health_monitor_builder_create(FFIHandle* health_monitor_builder_handle_out);
+FFICode health_monitor_builder_destroy(FFIHandle health_monitor_builder_handle);
+FFICode health_monitor_builder_build(FFIHandle health_monitor_builder_handle,
+                                     uint32_t supervisor_cycle_ms,
+                                     uint32_t internal_cycle_ms,
+                                     FFIHandle* health_monitor_handle_out);
+FFICode health_monitor_builder_add_deadline_monitor(FFIHandle health_monitor_builder_handle,
+                                                    const IdentTag* monitor_tag,
+                                                    FFIHandle deadline_monitor_builder_handle);
+FFICode health_monitor_get_deadline_monitor(FFIHandle health_monitor_handle,
+                                            const IdentTag* monitor_tag,
+                                            FFIHandle* deadline_monitor_handle_out);
+FFICode health_monitor_start(FFIHandle health_monitor_handle);
+FFICode health_monitor_destroy(FFIHandle health_monitor_handle);
+}
 
-// Health Monitor Foreign Function Interface Declarations that are exported by Rust implementation library
-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,
-                                                 uint32_t supervisor_cycle_ms,
-                                                 uint32_t internal_cycle_ms);
-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_start(internal::FFIHandle health_monitor_handle);
-void health_monitor_destroy(internal::FFIHandle handler);
+FFIHandle health_monitor_builder_create_wrapper()
+{
+    FFIHandle handle{nullptr};
+    auto result{health_monitor_builder_create(&handle)};
+    abort_on_error(result);
+    return handle;
 }
 
+}  // namespace
+
 // C++ wrapper for Rust library - the API implementation obeys the Rust API semantics and it's invariants
 
 namespace score::hm
 {
 
 HealthMonitorBuilder::HealthMonitorBuilder()
-    : health_monitor_builder_handle_{health_monitor_builder_create(), &health_monitor_builder_destroy}
+    : health_monitor_builder_handle_{health_monitor_builder_create_wrapper(), &health_monitor_builder_destroy}
 {
 }
 
 HealthMonitorBuilder HealthMonitorBuilder::add_deadline_monitor(const IdentTag& tag,
-                                                                deadline::DeadlineMonitorBuilder&& monitor) &&
+                                                                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());
+    auto result{health_monitor_builder_add_deadline_monitor(
+        health_monitor_builder_handle_.as_rust_handle().value(), &tag, monitor_handle.value())};
+    abort_on_error(result);
+
     return std::move(*this);
 }
 
@@ -67,16 +85,21 @@ HealthMonitorBuilder HealthMonitorBuilder::with_supervisor_api_cycle(std::chrono
 
 HealthMonitor HealthMonitorBuilder::build() &&
 {
-    auto handle = health_monitor_builder_handle_.drop_by_rust();
-    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
+    auto health_monitor_builder_handle = health_monitor_builder_handle_.drop_by_rust();
+    SCORE_LANGUAGE_FUTURECPP_PRECONDITION(health_monitor_builder_handle.has_value());
 
     uint32_t supervisor_duration_ms = static_cast<uint32_t>(supervisor_api_cycle_duration_.count());
     uint32_t internal_duration_ms = static_cast<uint32_t>(internal_processing_cycle_duration_.count());
 
-    return HealthMonitor(health_monitor_builder_build(handle.value(), supervisor_duration_ms, internal_duration_ms));
+    FFIHandle health_monitor_handle{nullptr};
+    auto result{health_monitor_builder_build(
+        health_monitor_builder_handle.value(), supervisor_duration_ms, internal_duration_ms, &health_monitor_handle)};
+    abort_on_error(result);
+
+    return HealthMonitor{health_monitor_handle};
 }
 
-HealthMonitor::HealthMonitor(internal::FFIHandle handle) : health_monitor_(handle)
+HealthMonitor::HealthMonitor(FFIHandle handle) : health_monitor_(handle)
 {
     // Initialize health monitor
 }
@@ -87,21 +110,22 @@ HealthMonitor::HealthMonitor(HealthMonitor&& other)
     other.health_monitor_ = nullptr;
 }
 
-score::cpp::expected<deadline::DeadlineMonitor, Error> HealthMonitor::get_deadline_monitor(const IdentTag& tag)
+score::cpp::expected<DeadlineMonitor, Error> HealthMonitor::get_deadline_monitor(const IdentTag& tag)
 {
-    auto maybe_monitor = health_monitor_get_deadline_monitor(health_monitor_, &tag);
-
-    if (maybe_monitor != nullptr)
+    FFIHandle handle{nullptr};
+    auto result{health_monitor_get_deadline_monitor(health_monitor_, &tag, &handle)};
+    if (result != kSuccess)
     {
-
-        return score::cpp::expected<deadline::DeadlineMonitor, Error>(deadline::DeadlineMonitor{maybe_monitor});
+        return score::cpp::unexpected(static_cast<Error>(result));
     }
 
-    return score::cpp::unexpected(Error::NotFound);
+    return score::cpp::expected<DeadlineMonitor, Error>(DeadlineMonitor{handle});
 }
+
 void HealthMonitor::start()
 {
-    health_monitor_start(health_monitor_);
+    auto result{health_monitor_start(health_monitor_)};
+    abort_on_error(result);
 }
 
 HealthMonitor::~HealthMonitor()