rclnodejs 1.7.0 → 1.8.0

package/src/clock_event.cpp

@@ -0,0 +1,268 @@
+// Copyright (c) 2025, The Robot Web Tools Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "clock_event.hpp"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+#include <rcl/time.h>
+#include <rcl/types.h>
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+
+#include "macros.h"
+#include "rcl_handle.h"
+
+namespace rclnodejs {
+
+template <typename ClockType>
+void ClockEvent::wait_until(rcl_clock_t* clock, rcl_time_point_t until) {
+  // Synchronize because clock epochs might differ
+  rcl_time_point_value_t now_value;
+  rcl_ret_t ret = rcl_clock_get_now(clock, &now_value);
+  if (RCL_RET_OK != ret) {
+    throw std::runtime_error("failed to get current time");
+  }
+  rcl_time_point_t rcl_entry;
+  rcl_entry.nanoseconds = now_value;
+  rcl_entry.clock_type = clock->type;
+
+  const typename ClockType::time_point chrono_entry = ClockType::now();
+
+  rcl_duration_t delta_t;
+  ret = rcl_difference_times(&rcl_entry, &until, &delta_t);
+
+  if (RCL_RET_OK != ret) {
+    throw std::runtime_error("failed to subtract times");
+  }
+
+  // Cast because system clock resolution is too big for nanoseconds on Windows
+  // & OSX
+  const typename ClockType::time_point chrono_until =
+      chrono_entry + std::chrono::duration_cast<typename ClockType::duration>(
+                         std::chrono::nanoseconds(delta_t.nanoseconds));
+
+  std::unique_lock<std::mutex> lock(mutex_);
+  cv_.wait_until(lock, chrono_until, [this]() { return state_; });
+}
+
+void ClockEvent::wait_until_ros(rcl_clock_t* clock, rcl_time_point_t until) {
+  bool is_enabled;
+  rcl_ret_t ret = rcl_is_enabled_ros_time_override(clock, &is_enabled);
+  if (RCL_RET_OK != ret) {
+    throw std::runtime_error("failed to check if ros time override is enabled");
+  }
+
+  // Check if ROS time is enabled in C++ to avoid TOCTTOU with TimeSource
+  if (is_enabled) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    // Caller must have setup a time jump callback to wake this event
+    cv_.wait(lock, [this]() { return state_; });
+  } else {
+    // ROS time not enabled is system time
+    wait_until<std::chrono::system_clock>(clock, until);
+  }
+}
+
+bool ClockEvent::is_set() {
+  std::unique_lock<std::mutex> lock(mutex_);
+  return state_;
+}
+
+void ClockEvent::set() {
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    state_ = true;
+  }
+  cv_.notify_all();
+}
+
+void ClockEvent::clear() {
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    state_ = false;
+  }
+  cv_.notify_all();
+}
+
+// Explicit instantiation
+template void ClockEvent::wait_until<std::chrono::steady_clock>(
+    rcl_clock_t* clock, rcl_time_point_t until);
+template void ClockEvent::wait_until<std::chrono::system_clock>(
+    rcl_clock_t* clock, rcl_time_point_t until);
+
+enum class WaitType { Steady, System, Ros };
+
+class ClockEventWaitWorker : public Napi::AsyncWorker {
+ public:
+  ClockEventWaitWorker(Napi::Env env, ClockEvent* event, rcl_clock_t* clock,
+                       int64_t until, WaitType type)
+      : Napi::AsyncWorker(env),
+        event_(event),
+        clock_(clock),
+        until_(until),
+        type_(type),
+        deferred_(Napi::Promise::Deferred::New(env)) {}
+
+  ~ClockEventWaitWorker() {}
+
+  void Execute() override {
+    try {
+      rcl_time_point_t until_time_point;
+      until_time_point.nanoseconds = until_;
+      until_time_point.clock_type = clock_->type;
+
+      switch (type_) {
+        case WaitType::Ros:
+          event_->wait_until_ros(clock_, until_time_point);
+          break;
+        case WaitType::Steady:
+          event_->wait_until<std::chrono::steady_clock>(clock_,
+                                                        until_time_point);
+          break;
+        case WaitType::System:
+          event_->wait_until<std::chrono::system_clock>(clock_,
+                                                        until_time_point);
+          break;
+      }
+    } catch (const std::exception& e) {
+      SetError(e.what());
+    }
+  }
+
+  void OnOK() override { deferred_.Resolve(Env().Undefined()); }
+
+  void OnError(const Napi::Error& e) override { deferred_.Reject(e.Value()); }
+
+  Napi::Promise Promise() { return deferred_.Promise(); }
+
+ private:
+  ClockEvent* event_;
+  rcl_clock_t* clock_;
+  int64_t until_;
+  WaitType type_;
+  Napi::Promise::Deferred deferred_;
+};
+
+Napi::Value CreateClockEvent(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  ClockEvent* event = new ClockEvent();
+  return RclHandle::NewInstance(env, event, nullptr, [](void* ptr) {
+    delete static_cast<ClockEvent*>(ptr);
+  });
+}
+
+Napi::Value ClockEventWaitUntilSteady(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  ClockEvent* event = static_cast<ClockEvent*>(event_handle->ptr());
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_clock_t* clock = static_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  bool lossless;
+  int64_t until = info[2].As<Napi::BigInt>().Int64Value(&lossless);
+  if (!lossless) {
+    Napi::TypeError::New(env, "until value lost precision during conversion")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  auto worker =
+      new ClockEventWaitWorker(env, event, clock, until, WaitType::Steady);
+  worker->Queue();
+  return worker->Promise();
+}
+
+Napi::Value ClockEventWaitUntilSystem(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  ClockEvent* event = static_cast<ClockEvent*>(event_handle->ptr());
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_clock_t* clock = static_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  bool lossless;
+  int64_t until = info[2].As<Napi::BigInt>().Int64Value(&lossless);
+  if (!lossless) {
+    Napi::TypeError::New(env, "until value lost precision during conversion")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  auto worker =
+      new ClockEventWaitWorker(env, event, clock, until, WaitType::System);
+  worker->Queue();
+  return worker->Promise();
+}
+
+Napi::Value ClockEventWaitUntilRos(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  ClockEvent* event = static_cast<ClockEvent*>(event_handle->ptr());
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_clock_t* clock = static_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  bool lossless;
+  int64_t until = info[2].As<Napi::BigInt>().Int64Value(&lossless);
+  if (!lossless) {
+    Napi::TypeError::New(env, "until value lost precision during conversion")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  auto worker =
+      new ClockEventWaitWorker(env, event, clock, until, WaitType::Ros);
+  worker->Queue();
+  return worker->Promise();
+}
+
+Napi::Value ClockEventIsSet(const Napi::CallbackInfo& info) {
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  ClockEvent* event = static_cast<ClockEvent*>(event_handle->ptr());
+  return Napi::Boolean::New(info.Env(), event->is_set());
+}
+
+Napi::Value ClockEventSet(const Napi::CallbackInfo& info) {
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  ClockEvent* event = static_cast<ClockEvent*>(event_handle->ptr());
+  event->set();
+  return info.Env().Undefined();
+}
+
+Napi::Value ClockEventClear(const Napi::CallbackInfo& info) {
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  ClockEvent* event = static_cast<ClockEvent*>(event_handle->ptr());
+  event->clear();
+  return info.Env().Undefined();
+}
+
+void InitClockEventBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("createClockEvent", Napi::Function::New(env, CreateClockEvent));
+  exports.Set("clockEventWaitUntilSteady",
+              Napi::Function::New(env, ClockEventWaitUntilSteady));
+  exports.Set("clockEventWaitUntilSystem",
+              Napi::Function::New(env, ClockEventWaitUntilSystem));
+  exports.Set("clockEventWaitUntilRos",
+              Napi::Function::New(env, ClockEventWaitUntilRos));
+  exports.Set("clockEventIsSet", Napi::Function::New(env, ClockEventIsSet));
+  exports.Set("clockEventSet", Napi::Function::New(env, ClockEventSet));
+  exports.Set("clockEventClear", Napi::Function::New(env, ClockEventClear));
+}
+
+}  // namespace rclnodejs

package/src/clock_event.hpp

@@ -0,0 +1,62 @@
+// Copyright (c) 2025, The Robot Web Tools Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_CLOCK_EVENT_HPP_
+#define SRC_CLOCK_EVENT_HPP_
+
+#include <napi.h>
+#include <rcl/time.h>
+
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+
+namespace rclnodejs {
+
+class ClockEvent {
+ public:
+  /// Wait until a time specified by a system or steady clock.
+  /// \param clock the clock to use for time synchronization with until
+  /// \param until this method will block until this time is reached.
+  template <typename ClockType>
+  void wait_until(rcl_clock_t* clock, rcl_time_point_t until);
+
+  /// Wait until a time specified by a ROS clock.
+  /// \warning The caller is responsible for creating a time jump callback
+  /// to set this event when the target ROS time is reached.
+  /// \param clock The clock to use for time synchronization.
+  /// \param until This method will block until this time is reached.
+  void wait_until_ros(rcl_clock_t* clock, rcl_time_point_t until);
+
+  /// Indicate if the ClockEvent is set.
+  /// \return True if the ClockEvent is set.
+  bool is_set();
+
+  /// Set the event.
+  void set();
+
+  /// Clear the event.
+  void clear();
+
+ private:
+  bool state_ = false;
+  std::mutex mutex_;
+  std::condition_variable cv_;
+};
+
+void InitClockEventBindings(Napi::Env env, Napi::Object exports);
+
+}  // namespace rclnodejs
+
+#endif  // SRC_CLOCK_EVENT_HPP_

package/src/macros.h

@@ -23,8 +23,7 @@
   {                                                                 \
     if (lhs op rhs) {                                               \
       rcl_reset_error();                                            \
-      Napi::Error::New(env, message)                                \
-          .ThrowAsJavaScriptException();                            \
+      Napi::Error::New(env, message).ThrowAsJavaScriptException();  \
       return env.Undefined();                                       \
     }                                                               \
   }
@@ -33,8 +32,7 @@
   {                                                                           \
     if (lhs op rhs) {                                                         \
       rcl_reset_error();                                                      \
-      Napi::Error::New(env, message)                                          \
-          .ThrowAsJavaScriptException();                                      \
+      Napi::Error::New(env, message).ThrowAsJavaScriptException();            \
     }                                                                         \
   }
 

package/src/rcl_action_server_bindings.cpp

@@ -317,9 +317,27 @@ Napi::Value ActionPublishStatus(const Napi::CallbackInfo& info) {
       rcl_action_get_goal_status_array(action_server, &status_message),
       RCL_RET_OK, rcl_get_error_string().str);
 
-  THROW_ERROR_IF_NOT_EQUAL(
-      rcl_action_publish_status(action_server, &status_message), RCL_RET_OK,
-      rcl_get_error_string().str);
+  rcl_ret_t ret = rcl_action_publish_status(action_server, &status_message);
+
+  std::string publish_error_msg;
+  if (ret != RCL_RET_OK) {
+    publish_error_msg = rcl_get_error_string().str;
+    rcl_reset_error();
+  }
+
+  rcl_ret_t ret_fini = rcl_action_goal_status_array_fini(&status_message);
+
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, publish_error_msg).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  if (ret_fini != RCL_RET_OK) {
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    return env.Undefined();
+  }
 
   return env.Undefined();
 }

package/src/rcl_bindings.cpp

@@ -15,6 +15,11 @@
 #include "rcl_bindings.h"
 
 #include <node.h>
+#include <rcl/arguments.h>
+#include <rcl/rcl.h>
+
+#include <rcpputils/scope_exit.hpp>
+
 #if ROS_VERSION >= 2006
 #include <rosidl_runtime_c/string_functions.h>
 #else
@@ -23,11 +28,64 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "rcl_handle.h"
+#include "rcl_utilities.h"
 
 namespace rclnodejs {
 
+Napi::Value RemoveROSArgs(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Array jsArgv = info[0].As<Napi::Array>();
+  size_t argc = jsArgv.Length();
+  char** argv = AbstractArgsFromNapiArray(jsArgv);
+
+  rcl_allocator_t allocator = rcl_get_default_allocator();
+  rcl_arguments_t parsed_args = rcl_get_zero_initialized_arguments();
+
+  rcl_ret_t ret = rcl_parse_arguments(argc, const_cast<const char**>(argv),
+                                      allocator, &parsed_args);
+
+  if (RCL_RET_OK != ret) {
+    FreeArgs(argv, argc);
+    Napi::Error::New(env, "Failed to parse arguments")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  RCPPUTILS_SCOPE_EXIT({
+    rcl_ret_t fini_ret = rcl_arguments_fini(&parsed_args);
+    if (RCL_RET_OK != fini_ret) {
+      // Log error but don't throw since we might be already throwing
+    }
+  });
+
+  int nonros_argc = 0;
+  const char** nonros_argv = nullptr;
+
+  ret = rcl_remove_ros_arguments(const_cast<const char**>(argv), &parsed_args,
+                                 allocator, &nonros_argc, &nonros_argv);
+
+  if (RCL_RET_OK != ret) {
+    FreeArgs(argv, argc);
+    Napi::Error::New(env, "Failed to remove ROS arguments")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  RCPPUTILS_SCOPE_EXIT({ allocator.deallocate(nonros_argv, allocator.state); });
+
+  Napi::Array result = Napi::Array::New(env, nonros_argc);
+  for (int i = 0; i < nonros_argc; ++i) {
+    result.Set(i, Napi::String::New(env, nonros_argv[i]));
+  }
+
+  FreeArgs(argv, argc);
+
+  return result;
+}
+
 Napi::Value InitString(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -110,6 +168,7 @@ Napi::Object InitBindings(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, CreateArrayBufferFromAddress));
   exports.Set("createArrayBufferCleaner",
               Napi::Function::New(env, CreateArrayBufferCleaner));
+  exports.Set("removeROSArgs", Napi::Function::New(env, RemoveROSArgs));
   return exports;
 }
 

package/src/rcl_context_bindings.cpp

@@ -73,6 +73,11 @@ Napi::Value Init(const Napi::CallbackInfo& info) {
       rcl_init(argc, argc > 0 ? argv : nullptr, &init_options, context),
       rcl_get_error_string().str);
 
+  ThrowIfUnparsedROSArgs(env, jsArgv, context->global_arguments);
+  if (env.IsExceptionPending()) {
+    return env.Undefined();
+  }
+
   THROW_ERROR_IF_NOT_EQUAL(
       RCL_RET_OK, rcl_logging_configure(&context->global_arguments, &allocator),
       rcl_get_error_string().str);

package/src/rcl_graph_bindings.cpp

@@ -33,6 +33,13 @@ typedef rcl_ret_t (*rcl_get_info_by_topic_func_t)(
     const char* topic_name, bool no_mangle,
     rcl_topic_endpoint_info_array_t* info_array);
 
+#if ROS_VERSION > 2505
+typedef rcl_ret_t (*rcl_get_info_by_service_func_t)(
+    const rcl_node_t* node, rcutils_allocator_t* allocator,
+    const char* service_name, bool no_mangle,
+    rcl_service_endpoint_info_array_t* info_array);
+#endif  // ROS_VERSION > 2505
+
 Napi::Value GetPublisherNamesAndTypesByNode(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -257,6 +264,66 @@ Napi::Value GetSubscriptionsInfoByTopic(const Napi::CallbackInfo& info) {
                         "subscriptions", rcl_get_subscriptions_info_by_topic);
 }
 
+#if ROS_VERSION > 2505
+Napi::Value GetInfoByService(
+    Napi::Env env, rcl_node_t* node, const char* service_name, bool no_mangle,
+    const char* type, rcl_get_info_by_service_func_t rcl_get_info_by_service) {
+  rcutils_allocator_t allocator = rcutils_get_default_allocator();
+  rcl_service_endpoint_info_array_t info_array =
+      rcl_get_zero_initialized_service_endpoint_info_array();
+
+  RCPPUTILS_SCOPE_EXIT({
+    rcl_ret_t fini_ret =
+        rcl_service_endpoint_info_array_fini(&info_array, &allocator);
+    if (RCL_RET_OK != fini_ret) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+  });
+
+  rcl_ret_t ret = rcl_get_info_by_service(node, &allocator, service_name,
+                                          no_mangle, &info_array);
+  if (RCL_RET_OK != ret) {
+    if (RCL_RET_UNSUPPORTED == ret) {
+      Napi::Error::New(
+          env, std::string("Failed to get information by service for ") + type +
+                   ": function not supported by RMW_IMPLEMENTATION")
+          .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+    Napi::Error::New(
+        env, std::string("Failed to get information by service for ") + type)
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  return ConvertToJSServiceEndpointInfoList(env, &info_array);
+}
+#endif  // ROS_VERSION > 2505
+
+#if ROS_VERSION > 2505
+Napi::Value GetClientsInfoByService(const Napi::CallbackInfo& info) {
+  RclHandle* node_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  std::string service_name = info[1].As<Napi::String>().Utf8Value();
+  bool no_mangle = info[2].As<Napi::Boolean>();
+
+  return GetInfoByService(info.Env(), node, service_name.c_str(), no_mangle,
+                          "clients", rcl_get_clients_info_by_service);
+}
+
+Napi::Value GetServersInfoByService(const Napi::CallbackInfo& info) {
+  RclHandle* node_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  std::string service_name = info[1].As<Napi::String>().Utf8Value();
+  bool no_mangle = info[2].As<Napi::Boolean>();
+
+  return GetInfoByService(info.Env(), node, service_name.c_str(), no_mangle,
+                          "servers", rcl_get_servers_info_by_service);
+}
+#endif  // ROS_VERSION > 2505
+
 Napi::Object InitGraphBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("getPublisherNamesAndTypesByNode",
               Napi::Function::New(env, GetPublisherNamesAndTypesByNode));
@@ -274,6 +341,12 @@ Napi::Object InitGraphBindings(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, GetPublishersInfoByTopic));
   exports.Set("getSubscriptionsInfoByTopic",
               Napi::Function::New(env, GetSubscriptionsInfoByTopic));
+#if ROS_VERSION > 2505
+  exports.Set("getClientsInfoByService",
+              Napi::Function::New(env, GetClientsInfoByService));
+  exports.Set("getServersInfoByService",
+              Napi::Function::New(env, GetServersInfoByService));
+#endif  // ROS_VERSION > 2505
   return exports;
 }