rclnodejs 1.7.0 → 1.8.0

package/src/rcl_logging_bindings.cpp

@@ -15,15 +15,105 @@
 #include "rcl_logging_bindings.h"
 
 #include <rcl/error_handling.h>
+#include <rcl/logging.h>
+#include <rcl/logging_rosout.h>
 #include <rcl/rcl.h>
+#include <rcl_logging_interface/rcl_logging_interface.h>
 
+#include <mutex>
 #include <string>
 
 #include "macros.h"
+#include "rcl_handle.h"
 #include "rcl_utilities.h"
 
 namespace rclnodejs {
 
+Napi::Value InitRosoutPublisherForNode(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* node_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+
+  if (rcl_logging_rosout_enabled()) {
+    rcl_ret_t ret = rcl_logging_rosout_init_publisher_for_node(node);
+    if (ret != RCL_RET_OK) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+  }
+  return env.Undefined();
+}
+
+static std::recursive_mutex logging_mutex;
+
+static void rclnodejs_thread_safe_logging_output_handler(
+    const rcutils_log_location_t* location, int severity, const char* name,
+    rcutils_time_point_value_t timestamp, const char* format, va_list* args) {
+  try {
+    std::lock_guard<std::recursive_mutex> lock(logging_mutex);
+    rcl_logging_multiple_output_handler(location, severity, name, timestamp,
+                                        format, args);
+  } catch (const std::exception& ex) {
+    RCUTILS_SAFE_FWRITE_TO_STDERR(
+        "rclnodejs failed to get the global logging mutex: ");
+    RCUTILS_SAFE_FWRITE_TO_STDERR(ex.what());
+    RCUTILS_SAFE_FWRITE_TO_STDERR("\n");
+  } catch (...) {
+    RCUTILS_SAFE_FWRITE_TO_STDERR(
+        "rclnodejs failed to get the global logging mutex\n");
+  }
+}
+
+Napi::Value LoggingConfigure(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* context_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_context_t* context =
+      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
+
+  rcl_allocator_t allocator = rcl_get_default_allocator();
+
+  std::lock_guard<std::recursive_mutex> lock(logging_mutex);
+  rcl_ret_t ret = rcl_logging_configure_with_output_handler(
+      &context->global_arguments, &allocator,
+      rclnodejs_thread_safe_logging_output_handler);
+
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+  }
+  return env.Undefined();
+}
+
+Napi::Value FiniRosoutPublisherForNode(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* node_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+
+  if (rcl_logging_rosout_enabled()) {
+    rcl_ret_t ret = rcl_logging_rosout_fini_publisher_for_node(node);
+    if (ret != RCL_RET_OK) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+  }
+  return env.Undefined();
+}
+
+Napi::Value LoggingFini(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  std::lock_guard<std::recursive_mutex> lock(logging_mutex);
+  rcl_ret_t ret = rcl_logging_fini();
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+  }
+  return env.Undefined();
+}
+
 Napi::Value setLoggerLevel(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -84,12 +174,80 @@ Napi::Value IsEnableFor(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, enabled);
 }
 
+Napi::Value GetLoggingDirectory(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  rcutils_allocator_t allocator = rcutils_get_default_allocator();
+  char* directory_path = nullptr;
+  rcl_logging_ret_t ret =
+      rcl_logging_get_logging_directory(allocator, &directory_path);
+
+  if (ret != RCL_LOGGING_RET_OK) {
+    Napi::Error::New(env, rcutils_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcutils_reset_error();
+    return env.Undefined();
+  }
+
+  Napi::String result = Napi::String::New(env, directory_path);
+  allocator.deallocate(directory_path, allocator.state);
+  return result;
+}
+
+#if ROS_VERSION > 2205
+Napi::Value AddRosoutSublogger(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  std::string logger_name = info[0].As<Napi::String>().Utf8Value();
+  std::string sublogger_name = info[1].As<Napi::String>().Utf8Value();
+
+  rcl_ret_t ret = rcl_logging_rosout_add_sublogger(logger_name.c_str(),
+                                                   sublogger_name.c_str());
+  if (ret == RCL_RET_OK) {
+    return Napi::Boolean::New(env, true);
+  } else if (ret == RCL_RET_NOT_FOUND) {
+    rcl_reset_error();
+    return Napi::Boolean::New(env, false);
+  } else {
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    return env.Undefined();
+  }
+}
+
+Napi::Value RemoveRosoutSublogger(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  std::string logger_name = info[0].As<Napi::String>().Utf8Value();
+  std::string sublogger_name = info[1].As<Napi::String>().Utf8Value();
+
+  rcl_ret_t ret = rcl_logging_rosout_remove_sublogger(logger_name.c_str(),
+                                                      sublogger_name.c_str());
+  if (ret != RCL_RET_OK) {
+    rcl_reset_error();
+  }
+  return env.Undefined();
+}
+#endif
+
 Napi::Object InitLoggingBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("setLoggerLevel", Napi::Function::New(env, setLoggerLevel));
   exports.Set("getLoggerEffectiveLevel",
               Napi::Function::New(env, GetLoggerEffectiveLevel));
   exports.Set("log", Napi::Function::New(env, Log));
   exports.Set("isEnableFor", Napi::Function::New(env, IsEnableFor));
+  exports.Set("getLoggingDirectory",
+              Napi::Function::New(env, GetLoggingDirectory));
+  exports.Set("initRosoutPublisherForNode",
+              Napi::Function::New(env, InitRosoutPublisherForNode));
+  exports.Set("finiRosoutPublisherForNode",
+              Napi::Function::New(env, FiniRosoutPublisherForNode));
+#if ROS_VERSION > 2205
+  exports.Set("addRosoutSublogger",
+              Napi::Function::New(env, AddRosoutSublogger));
+  exports.Set("removeRosoutSublogger",
+              Napi::Function::New(env, RemoveRosoutSublogger));
+#endif
+  exports.Set("loggingConfigure", Napi::Function::New(env, LoggingConfigure));
+  exports.Set("loggingFini", Napi::Function::New(env, LoggingFini));
   return exports;
 }
 

package/src/rcl_node_bindings.cpp

@@ -26,8 +26,10 @@
 #include <rcl_yaml_param_parser/types.h>
 
 #include <rcpputils/scope_exit.hpp>
-// NOLINTNEXTLINE
+// NOLINTBEGIN
+#include <memory>
 #include <string>
+// NOLINTEND
 
 #include "macros.h"
 #include "rcl_handle.h"
@@ -191,12 +193,17 @@ Napi::Value CreateNode(const Napi::CallbackInfo& info) {
   rcl_arguments_t arguments = rcl_get_zero_initialized_arguments();
   rcl_ret_t ret =
       rcl_parse_arguments(argc, argv, rcl_get_default_allocator(), &arguments);
-  if ((ret != RCL_RET_OK) || HasUnparsedROSArgs(arguments)) {
+  if (ret != RCL_RET_OK) {
     Napi::Error::New(env, "failed to parse arguments")
         .ThrowAsJavaScriptException();
     return env.Undefined();
   }
 
+  ThrowIfUnparsedROSArgs(env, jsArgv, arguments);
+  if (env.IsExceptionPending()) {
+    return env.Undefined();
+  }
+
   RCPPUTILS_SCOPE_EXIT({
     if (RCL_RET_OK != rcl_arguments_fini(&arguments)) {
       Napi::Error::New(env, "failed to fini arguments")
@@ -212,6 +219,11 @@ Napi::Value CreateNode(const Napi::CallbackInfo& info) {
   options.use_global_arguments = use_global_arguments;
   options.arguments = arguments;
 
+  if (info.Length() > 5 && !info[5].IsUndefined() && !info[5].IsNull()) {
+    std::unique_ptr<rmw_qos_profile_t> qos_profile = GetQoSProfile(info[5]);
+    options.rosout_qos = *qos_profile;
+  }
+
   THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
                            rcl_node_init(node, node_name.c_str(),
                                          name_space.c_str(), context, &options),

package/src/rcl_publisher_bindings.cpp

@@ -147,6 +147,17 @@ Napi::Value WaitForAllAcked(const Napi::CallbackInfo& info) {
   return env.Undefined();
 }
 
+Napi::Value AssertLiveliness(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  rcl_publisher_t* publisher = reinterpret_cast<rcl_publisher_t*>(
+      RclHandle::Unwrap(info[0].As<Napi::Object>())->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(rcl_publisher_assert_liveliness(publisher),
+                           RCL_RET_OK, rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
 Napi::Object InitPublisherBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("createPublisher", Napi::Function::New(env, CreatePublisher));
   exports.Set("publish", Napi::Function::New(env, Publish));
@@ -155,6 +166,7 @@ Napi::Object InitPublisherBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("getSubscriptionCount",
               Napi::Function::New(env, GetSubscriptionCount));
   exports.Set("waitForAllAcked", Napi::Function::New(env, WaitForAllAcked));
+  exports.Set("assertLiveliness", Napi::Function::New(env, AssertLiveliness));
   return exports;
 }
 

package/src/rcl_service_bindings.cpp

@@ -77,11 +77,11 @@ Napi::Value RclTakeRequest(const Napi::CallbackInfo& info) {
 
   rcl_service_t* service = reinterpret_cast<rcl_service_t*>(
       RclHandle::Unwrap(info[0].As<Napi::Object>())->ptr());
-  rmw_request_id_t* header =
-      reinterpret_cast<rmw_request_id_t*>(malloc(sizeof(rmw_request_id_t)));
+  rmw_service_info_t* header =
+      reinterpret_cast<rmw_service_info_t*>(malloc(sizeof(rmw_service_info_t)));
 
   void* taken_request = info[2].As<Napi::Buffer<char>>().Data();
-  rcl_ret_t ret = rcl_take_request(service, header, taken_request);
+  rcl_ret_t ret = rcl_take_request_with_info(service, header, taken_request);
   if (ret != RCL_RET_SERVICE_TAKE_FAILED) {
     auto js_obj = RclHandle::NewInstance(env, header, nullptr,
                                          [](void* ptr) { free(ptr); });
@@ -98,11 +98,12 @@ Napi::Value SendResponse(const Napi::CallbackInfo& info) {
       RclHandle::Unwrap(info[0].As<Napi::Object>())->ptr());
   void* buffer = info[1].As<Napi::Buffer<char>>().Data();
 
-  rmw_request_id_t* header = reinterpret_cast<rmw_request_id_t*>(
+  rmw_service_info_t* header = reinterpret_cast<rmw_service_info_t*>(
       RclHandle::Unwrap(info[2].As<Napi::Object>())->ptr());
 
-  THROW_ERROR_IF_NOT_EQUAL(rcl_send_response(service, header, buffer),
-                           RCL_RET_OK, rcl_get_error_string().str);
+  THROW_ERROR_IF_NOT_EQUAL(
+      rcl_send_response(service, &(header->request_id), buffer), RCL_RET_OK,
+      rcl_get_error_string().str);
 
   return env.Undefined();
 }

package/src/rcl_subscription_bindings.cpp

@@ -76,7 +76,6 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
     subscription_ops.qos = *qos_profile;
   }
 
-#if ROS_VERSION >= 2205  // 2205 => Humble+
   if (options.Has("contentFilter")) {
     // configure content-filter
     Napi::Value contentFilterVal = options.Get("contentFilter");
@@ -123,7 +122,6 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
       }
     }
   }
-#endif
 
   const rosidl_message_type_support_t* ts =
       GetMessageTypeSupport(package_name, message_sub_folder, message_name);
@@ -201,9 +199,6 @@ Napi::Value GetSubscriptionTopic(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value HasContentFilter(const Napi::CallbackInfo& info) {
-#if ROS_VERSION < 2205  // 2205 => Humble+
-  return Napi::Boolean::New(info.Env(), false);
-#else
   Napi::Env env = info.Env();
 
   RclHandle* subscription_handle =
@@ -213,13 +208,9 @@ Napi::Value HasContentFilter(const Napi::CallbackInfo& info) {
 
   bool is_valid = rcl_subscription_is_cft_enabled(subscription);
   return Napi::Boolean::New(env, is_valid);
-#endif
 }
 
 Napi::Value SetContentFilter(const Napi::CallbackInfo& info) {
-#if ROS_VERSION < 2205  // 2205 => Humble+
-  return Napi::Boolean::New(info.Env(), false);
-#else
   Napi::Env env = info.Env();
 
   RclHandle* subscription_handle =
@@ -272,13 +263,9 @@ Napi::Value SetContentFilter(const Napi::CallbackInfo& info) {
   }
 
   return Napi::Boolean::New(env, true);
-#endif
 }
 
 Napi::Value ClearContentFilter(const Napi::CallbackInfo& info) {
-#if ROS_VERSION < 2205  // 2205 => Humble+
-  return Napi::Boolean::New(info.Env(), false);
-#else
   Napi::Env env = info.Env();
 
   RclHandle* subscription_handle =
@@ -301,7 +288,56 @@ Napi::Value ClearContentFilter(const Napi::CallbackInfo& info) {
       rcl_get_error_string().str);
 
   return Napi::Boolean::New(env, true);
-#endif
+}
+
+Napi::Value GetContentFilter(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* subscription_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_subscription_t* subscription =
+      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
+
+  rcl_subscription_content_filter_options_t options =
+      rcl_get_zero_initialized_subscription_content_filter_options();
+
+  rcl_ret_t ret = rcl_subscription_get_content_filter(subscription, &options);
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    return env.Undefined();
+  }
+
+  // Create result object
+  Napi::Object result = Napi::Object::New(env);
+  result.Set(
+      "expression",
+      Napi::String::New(
+          env,
+          options.rmw_subscription_content_filter_options.filter_expression));
+
+  size_t param_count = options.rmw_subscription_content_filter_options
+                           .expression_parameters.size;
+  Napi::Array parameters = Napi::Array::New(env, param_count);
+  for (size_t i = 0; i < param_count; ++i) {
+    parameters[i] =
+        Napi::String::New(env, options.rmw_subscription_content_filter_options
+                                   .expression_parameters.data[i]);
+  }
+  result.Set("parameters", parameters);
+
+  // Cleanup
+  rcl_ret_t fini_ret =
+      rcl_subscription_content_filter_options_fini(subscription, &options);
+  if (fini_ret != RCL_RET_OK) {
+    Napi::Error::New(env, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    return env.Undefined();
+  }
+
+  return result;
 }
 
 Napi::Value GetPublisherCount(const Napi::CallbackInfo& info) {
@@ -327,6 +363,7 @@ Napi::Object InitSubscriptionBindings(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, GetSubscriptionTopic));
   exports.Set("hasContentFilter", Napi::Function::New(env, HasContentFilter));
   exports.Set("setContentFilter", Napi::Function::New(env, SetContentFilter));
+  exports.Set("getContentFilter", Napi::Function::New(env, GetContentFilter));
   exports.Set("clearContentFilter",
               Napi::Function::New(env, ClearContentFilter));
   exports.Set("getPublisherCount", Napi::Function::New(env, GetPublisherCount));

package/src/rcl_time_point_bindings.cpp

@@ -175,9 +175,144 @@ Napi::Value ClockGetNow(const Napi::CallbackInfo& info) {
   return Napi::BigInt::New(env, time_point.nanoseconds);
 }
 
+struct JumpCallbackData {
+  Napi::ThreadSafeFunction tsfn_pre;
+  Napi::ThreadSafeFunction tsfn_post;
+};
+
+struct JumpCallbackContext {
+  rcl_time_jump_t time_jump;
+  bool before_jump;
+};
+
+void _rclnodejs_on_time_jump(const rcl_time_jump_t* time_jump, bool before_jump,
+                             void* user_data) {
+  JumpCallbackData* data = static_cast<JumpCallbackData*>(user_data);
+
+  auto context = new JumpCallbackContext{*time_jump, before_jump};
+
+  if (before_jump) {
+    auto callback = [](Napi::Env env, Napi::Function js_callback,
+                       JumpCallbackContext* context) {
+      js_callback.Call({});
+      delete context;
+    };
+    data->tsfn_pre.NonBlockingCall(context, callback);
+  } else {
+    auto callback = [](Napi::Env env, Napi::Function js_callback,
+                       JumpCallbackContext* context) {
+      Napi::Object jump_info = Napi::Object::New(env);
+      jump_info.Set("clock_change",
+                    static_cast<int32_t>(context->time_jump.clock_change));
+      jump_info.Set("delta", Napi::BigInt::New(
+                                 env, context->time_jump.delta.nanoseconds));
+      js_callback.Call({jump_info});
+      delete context;
+    };
+    data->tsfn_post.NonBlockingCall(context, callback);
+  }
+}
+
+Napi::Value ClockAddJumpCallback(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  Napi::Object callback_obj = info[1].As<Napi::Object>();
+  Napi::Function pre_callback =
+      callback_obj.Get("_pre_callback").As<Napi::Function>();
+  Napi::Function post_callback =
+      callback_obj.Get("_post_callback").As<Napi::Function>();
+
+  bool on_clock_change = info[2].As<Napi::Boolean>();
+
+  bool lossless;
+  int64_t min_forward = info[3].As<Napi::BigInt>().Int64Value(&lossless);
+  if (!lossless) {
+    Napi::TypeError::New(
+        env, "min_forward BigInt value cannot be represented as int64_t")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int64_t min_backward = info[4].As<Napi::BigInt>().Int64Value(&lossless);
+  if (!lossless) {
+    Napi::TypeError::New(
+        env, "min_backward BigInt value cannot be represented as int64_t")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  rcl_jump_threshold_t threshold;
+  threshold.on_clock_change = on_clock_change;
+  threshold.min_forward.nanoseconds = min_forward;
+  threshold.min_backward.nanoseconds = min_backward;
+
+  JumpCallbackData* data = new JumpCallbackData();
+  data->tsfn_pre = Napi::ThreadSafeFunction::New(
+      env, pre_callback, "ClockJumpPreCallback", 10, 1, [](Napi::Env) {});
+  data->tsfn_post =
+      Napi::ThreadSafeFunction::New(env, post_callback, "ClockJumpPostCallback",
+                                    10, 1, [data](Napi::Env) { delete data; });
+
+  Napi::Object handle_obj = Napi::Object::New(env);
+  handle_obj.Set("_cpp_handle",
+                 Napi::External<JumpCallbackData>::New(env, data));
+
+  rcl_ret_t ret = rcl_clock_add_jump_callback(clock, threshold,
+                                              _rclnodejs_on_time_jump, data);
+
+  if (ret != RCL_RET_OK) {
+    data->tsfn_pre.Release();
+    data->tsfn_post.Release();
+    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+  }
+
+  callback_obj.Set("_cpp_handle", handle_obj.Get("_cpp_handle"));
+
+  return env.Undefined();
+}
+
+Napi::Value ClockRemoveJumpCallback(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  Napi::Object handle_obj = info[1].As<Napi::Object>();
+  Napi::Value cpp_handle = handle_obj.Get("_cpp_handle");
+
+  if (cpp_handle.IsUndefined() || !cpp_handle.IsExternal()) {
+    Napi::Error::New(env,
+                     "Callback object was not registered or already removed")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  JumpCallbackData* data =
+      cpp_handle.As<Napi::External<JumpCallbackData>>().Data();
+
+  rcl_ret_t ret =
+      rcl_clock_remove_jump_callback(clock, _rclnodejs_on_time_jump, data);
+
+  if (ret == RCL_RET_OK) {
+    data->tsfn_pre.Release();
+    data->tsfn_post.Release();
+    handle_obj.Set("_cpp_handle", env.Undefined());
+  } else {
+    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+  }
+
+  return env.Undefined();
+}
+
 Napi::Object InitTimePointBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("createClock", Napi::Function::New(env, CreateClock));
   exports.Set("clockGetNow", Napi::Function::New(env, ClockGetNow));
+  exports.Set("clockAddJumpCallback",
+              Napi::Function::New(env, ClockAddJumpCallback));
+  exports.Set("clockRemoveJumpCallback",
+              Napi::Function::New(env, ClockRemoveJumpCallback));
   exports.Set("createTimePoint", Napi::Function::New(env, CreateTimePoint));
   exports.Set("getNanoseconds", Napi::Function::New(env, GetNanoseconds));
   exports.Set("createDuration", Napi::Function::New(env, CreateDuration));