30.1.2

Signed-off-by: Alejandro Hernandez Cordero <ahcorde@gmail.com>

rclcpp/CHANGELOG.rst

@@ -2,6 +2,62 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+30.1.2 (2025-10-21)
+-------------------
+* clear handles before node destruction in test_memory_strategy. (`#2969 <https://github.com/ros2/rclcpp/issues/2969>`_)
+* Added static assert asserting custom types have no overloaded operator new (`#2954 <https://github.com/ros2/rclcpp/issues/2954>`_)
+* Store graph listener inside the context instead of the node graph (`#2952 <https://github.com/ros2/rclcpp/issues/2952>`_)
+* Reapply "Catch the exception from rate.sleep() if the context is invalid. (`#2956 <https://github.com/ros2/rclcpp/issues/2956>`_)" (`#2963 <https://github.com/ros2/rclcpp/issues/2963>`_) (`#2964 <https://github.com/ros2/rclcpp/issues/2964>`_)
+* Revert "Catch the exception from rate.sleep() if the context is invalid. (`#2956 <https://github.com/ros2/rclcpp/issues/2956>`_)" (`#2963 <https://github.com/ros2/rclcpp/issues/2963>`_)
+* Catch the exception from rate.sleep() if the context is invalid. (`#2956 <https://github.com/ros2/rclcpp/issues/2956>`_)
+* update Time documentation (`#2955 <https://github.com/ros2/rclcpp/issues/2955>`_)
+* Contributors: Ilario A. Azzollini, Ivo Ivanov, Skyler Medeiros, Tomoya Fujita
+
+30.1.1 (2025-09-11)
+-------------------
+* Removed warning (`#2949 <https://github.com/ros2/rclcpp/issues/2949>`_)
+* add note about problems with spin_until_future_complete (`#2849 <https://github.com/ros2/rclcpp/issues/2849>`_)
+* deprecate rclcpp::spin_some and rclcpp::spin_all (`#2848 <https://github.com/ros2/rclcpp/issues/2848>`_)
+* Improve the function extract_type_identifier (`#2923 <https://github.com/ros2/rclcpp/issues/2923>`_)
+* Allow for implicitly convertable loggers as well (`#2922 <https://github.com/ros2/rclcpp/issues/2922>`_)
+* Contributors: Alberto Soragna, Alejandro Hernández Cordero, Barry Xu, Tim Clephas
+
+30.1.0 (2025-07-29)
+-------------------
+* Fix: improve exception context for parameter_value_from (`#2917 <https://github.com/ros2/rclcpp/issues/2917>`_)
+* Fix `start_type_description_service` param handling (`#2897 <https://github.com/ros2/rclcpp/issues/2897>`_)
+* Add qos parameter for wait_for_message function (`#2903 <https://github.com/ros2/rclcpp/issues/2903>`_)
+* Fujitatomoya/test append parameter override (`#2896 <https://github.com/ros2/rclcpp/issues/2896>`_)
+* Expose `typesupport_helpers` API needed for the Rosbag2 (`#2858 <https://github.com/ros2/rclcpp/issues/2858>`_)
+* Remove comment about now-removed StaticSingleThreadedExecutor (`#2893 <https://github.com/ros2/rclcpp/issues/2893>`_)
+* Add overload of `append_parameter_override` (`#2891 <https://github.com/ros2/rclcpp/issues/2891>`_)
+* fix: Don't deadlock if removing shutdown callbacks in a shutdown callback (`#2886 <https://github.com/ros2/rclcpp/issues/2886>`_)
+* Contributors: Christophe Bedard, Janosch Machowinski, Michael Orlov, Michiel Leegwater, Patrick Roncagliolo, Sriharsha Ghanta, Tomoya Fujita
+
+30.0.0 (2025-07-01)
+-------------------
+* Hand-code logging.hpp (`#2870 <https://github.com/ros2/rclcpp/issues/2870>`_)
+* Adressed TODO in node_graph (`#2877 <https://github.com/ros2/rclcpp/issues/2877>`_)
+* fix test_publisher_with_system_default_qos. (`#2881 <https://github.com/ros2/rclcpp/issues/2881>`_)
+* Contributors: Alejandro Hernández Cordero, Chris Lalancette, Tomoya Fujita
+
+29.6.1 (2025-06-23)
+-------------------
+* Fix for memory leaks in rclcpp::SerializedMessage (`#2861 <https://github.com/ros2/rclcpp/issues/2861>`_)
+* Removed warning test_qos (`#2859 <https://github.com/ros2/rclcpp/issues/2859>`_)
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* get_all_data_impl() does not handle null pointers properly, causing segmentation fault (`#2840 <https://github.com/ros2/rclcpp/issues/2840>`_)
+* QoSInitialization::from_rmw does not validate invalid history policy values, leading to silent failures (`#2841 <https://github.com/ros2/rclcpp/issues/2841>`_)
+* remove get_notify_guard_condition from NodeBaseInterface. (`#2839 <https://github.com/ros2/rclcpp/issues/2839>`_)
+* Removed deprecated StaticSingleThreadedExecutor (`#2835 <https://github.com/ros2/rclcpp/issues/2835>`_)
+* Removed deprecated rcpputils Path (`#2834 <https://github.com/ros2/rclcpp/issues/2834>`_)
+* Add range constraints for applicable array parameters (`#2828 <https://github.com/ros2/rclcpp/issues/2828>`_)
+* Update RingBufferImplementation to clear internal data. (`#2837 <https://github.com/ros2/rclcpp/issues/2837>`_)
+* Removed deprecated cancel_sleep_or_wait (`#2836 <https://github.com/ros2/rclcpp/issues/2836>`_)
+* Add missing 's' to 'NodeParametersInterface' in doc/comment (`#2831 <https://github.com/ros2/rclcpp/issues/2831>`_)
+* subordinate node consistent behavior and update docstring. (`#2822 <https://github.com/ros2/rclcpp/issues/2822>`_)
+* Contributors: Alejandro Hernández Cordero, Alex Youngs, Christophe Bedard, Michael Carlstrom, Michael Orlov, Tomoya Fujita
+
 29.6.0 (2025-04-25)
 -------------------
 * throws std::invalid_argument if ParameterEvent is NULL. (`#2814 <https://github.com/ros2/rclcpp/issues/2814>`_)

rclcpp/CMakeLists.txt

@@ -70,7 +70,6 @@ set(${PROJECT_NAME}_SRCS
   src/rclcpp/executors/executor_notify_waitable.cpp
   src/rclcpp/executors/multi_threaded_executor.cpp
   src/rclcpp/executors/single_threaded_executor.cpp
-  src/rclcpp/executors/static_single_threaded_executor.cpp
   src/rclcpp/expand_topic_or_service_name.cpp
   src/rclcpp/experimental/executors/events_executor/events_executor.cpp
   src/rclcpp/experimental/timers_manager.cpp
@@ -147,27 +146,6 @@ set(Python3_FIND_UNVERSIONED_NAMES FIRST)
 
 find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
-# "watch" template for changes
-configure_file(
-  "resource/logging.hpp.em"
-  "logging.hpp.em.watch"
-  COPYONLY
-)
-# generate header with logging macros
-set(python_code_logging
-  "import em"
-  "em.invoke(['-o', 'include/rclcpp/logging.hpp', '${CMAKE_CURRENT_SOURCE_DIR}/resource/logging.hpp.em'])")
-string(REPLACE ";" "$<SEMICOLON>" python_code_logging "${python_code_logging}")
-add_custom_command(OUTPUT include/rclcpp/logging.hpp
-  COMMAND ${CMAKE_COMMAND} -E make_directory "include/rclcpp"
-  COMMAND Python3::Interpreter ARGS -c "${python_code_logging}"
-  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/logging.hpp.em.watch"
-  COMMENT "Expanding logging.hpp.em"
-  VERBATIM
-)
-list(APPEND ${PROJECT_NAME}_SRCS
-  include/rclcpp/logging.hpp)
-
 file(GLOB interface_files "include/rclcpp/node_interfaces/node_*_interface.hpp")
 foreach(interface_file ${interface_files})
   get_filename_component(interface_name ${interface_file} NAME_WE)

rclcpp/Doxyfile

@@ -21,6 +21,22 @@ GENERATE_LATEX         = NO
 ENABLE_PREPROCESSING   = YES
 MACRO_EXPANSION        = YES
 EXPAND_ONLY_PREDEF     = YES
+EXCLUDE_SYMBOLS        += RCLCPP_STATIC_ASSERT_LOGGER
+EXCLUDE_SYMBOLS        += RCLCPP_LOG
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_ONCE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_EXPRESSION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_FUNCTION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_SKIPFIRST
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_TIME_POINT_FUNC
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_THROTTLE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_SKIPFIRST_THROTTLE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_ONCE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_EXPRESSION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_FUNCTION
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_SKIPFIRST
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_THROTTLE
+EXCLUDE_SYMBOLS        += RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
 PREDEFINED             += DOXYGEN_ONLY
 PREDEFINED             += RCLCPP_LOCAL=
 PREDEFINED             += RCLCPP_PUBLIC=

rclcpp/include/rclcpp/context.hpp

@@ -37,6 +37,10 @@
 
 namespace rclcpp
 {
+namespace graph_listener
+{
+class GraphListener;
+}  // namespace graph_listener
 
 /// Thrown when init is called on an already initialized context.
 class ContextAlreadyInitialized : public std::runtime_error
@@ -309,6 +313,10 @@ public:
   std::shared_ptr<rcl_context_t>
   get_rcl_context();
 
+  RCLCPP_PUBLIC
+  std::shared_ptr<rclcpp::graph_listener::GraphListener>
+  get_graph_listener();
+
   /// Sleep for a given period of time or until shutdown() is called.
   /**
    * This function can be interrupted early if:
@@ -381,16 +389,19 @@ private:
   std::recursive_mutex sub_contexts_mutex_;
 
   std::vector<std::shared_ptr<OnShutdownCallback>> on_shutdown_callbacks_;
-  mutable std::mutex on_shutdown_callbacks_mutex_;
+  mutable std::recursive_mutex on_shutdown_callbacks_mutex_;
 
   std::vector<std::shared_ptr<PreShutdownCallback>> pre_shutdown_callbacks_;
-  mutable std::mutex pre_shutdown_callbacks_mutex_;
+  mutable std::recursive_mutex pre_shutdown_callbacks_mutex_;
 
   /// Condition variable for timed sleep (see sleep_for).
   std::condition_variable interrupt_condition_variable_;
   /// Mutex for protecting the global condition variable.
   std::mutex interrupt_mutex_;
 
+  /// Graph Listener which waits on graph changes for the node and is shared across nodes.
+  std::shared_ptr<rclcpp::graph_listener::GraphListener> graph_listener_;
+
   /// Keep shared ownership of global vector of weak contexts
   std::shared_ptr<WeakContextsWrapper> weak_contexts_;
 

rclcpp/include/rclcpp/executor.hpp

@@ -371,6 +371,9 @@ public:
    *   If the time spent inside the blocking loop exceeds this timeout, return a TIMEOUT return
    *   code.
    * \return The return code, one of `SUCCESS`, `INTERRUPTED`, or `TIMEOUT`.
+   * \note This method will check the future and the timeout only when the executor is woken up.
+   *   If this future is unrelated to an executor's entity, this method will not correctly detect
+   *   when it's completed and therefore may wait forever and never time out.
    */
   template<typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::milli>
   FutureReturnCode

rclcpp/include/rclcpp/executors.hpp

@@ -20,7 +20,6 @@
 
 #include "rclcpp/executors/multi_threaded_executor.hpp"
 #include "rclcpp/executors/single_threaded_executor.hpp"
-#include "rclcpp/executors/static_single_threaded_executor.hpp"
 #include "rclcpp/experimental/executors/events_executor/events_executor.hpp"
 #include "rclcpp/node.hpp"
 #include "rclcpp/utilities.hpp"
@@ -29,24 +28,82 @@
 namespace rclcpp
 {
 
-/// Create a default single-threaded executor and execute all available work exhaustively.
-/** \param[in] node_ptr Shared pointer to the node to spin. */
+/**
+ * @brief Create a default single-threaded executor and execute all available work exhaustively.
+ * @param node_ptr Shared pointer to the base interface of the node to spin.
+ * @param max_duration max duration to spin
+ *
+ * This method is deprecated because it can lead to very bad performance if used in a loop:
+ * each call will create a new executor and register the node, which is an expensive operation.
+ * It's recommended to always manually instantiate an executor and call the methods with
+ * the same name on it.
+ * For example:
+ *     SingleThreadedExecutor executor;
+ *     executor.add_node(node_ptr);
+ *     executor.spin_all(max_duration);
+ * If you are using a non-default context, this should be passed to the executor's constructor.
+ */
+[[deprecated("use SingleThreadedExecutor::spin_all instead")]]
 RCLCPP_PUBLIC
 void
 spin_all(
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
   std::chrono::nanoseconds max_duration);
 
+/**
+ * @brief Create a default single-threaded executor and execute all available work exhaustively.
+ * @param node_ptr Shared pointer to the node to spin.
+ * @param max_duration max duration to spin
+ *
+ * This method is deprecated because it can lead to very bad performance if used in a loop:
+ * each call will create a new executor and register the node, which is an expensive operation.
+ * It's recommended to always manually instantiate an executor and call the methods with
+ * the same name on it.
+ * For example:
+ *     SingleThreadedExecutor executor;
+ *     executor.add_node(node_ptr);
+ *     executor.spin_all(max_duration);
+ * If you are using a non-default context, this should be passed to the executor's constructor.
+ */
+[[deprecated("use SingleThreadedExecutor::spin_all instead")]]
 RCLCPP_PUBLIC
 void
 spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration);
 
-/// Create a default single-threaded executor and execute any immediately available work.
-/** \param[in] node_ptr Shared pointer to the node to spin. */
+/**
+ * @brief Create a default single-threaded executor and execute any immediately available work.
+ * @param node_ptr Shared pointer to the base interface of the node to spin.
+ *
+ * This method is deprecated because it can lead to very bad performance if used in a loop:
+ * each call will create a new executor and register the node, which is an expensive operation.
+ * It's recommended to always manually instantiate an executor and call the methods with
+ * the same name on it.
+ * For example:
+ *     SingleThreadedExecutor executor;
+ *     executor.add_node(node_ptr);
+ *     executor.spin_some();
+ * If you are using a non-default context, this should be passed to the executor's constructor.
+ */
+[[deprecated("use SingleThreadedExecutor::spin_some instead")]]
 RCLCPP_PUBLIC
 void
 spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);
 
+/**
+ * @brief Create a default single-threaded executor and execute any immediately available work.
+ * @param node_ptr Shared pointer to the node to spin.
+ *
+ * This method is deprecated because it can lead to very bad performance if used in a loop:
+ * each call will create a new executor and register the node, which is an expensive operation.
+ * It's recommended to always manually instantiate an executor and call the methods with
+ * the same name on it.
+ * For example:
+ *     SingleThreadedExecutor executor;
+ *     executor.add_node(node_ptr);
+ *     executor.spin_some();
+ * If you are using a non-default context, this should be passed to the executor's constructor.
+ */
+[[deprecated("use SingleThreadedExecutor::spin_some instead")]]
 RCLCPP_PUBLIC
 void
 spin_some(rclcpp::Node::SharedPtr node_ptr);

rclcpp/include/rclcpp/executors/static_single_threaded_executor.hpp

@@ -1,145 +0,0 @@
-// Copyright 2019 Nobleo Technology
-//
-// 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 RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_
-#define RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_
-
-#include <atomic>
-#include <chrono>
-#include <memory>
-
-#include "rclcpp/executor.hpp"
-#include "rclcpp/executors/executor_entities_collection.hpp"
-#include "rclcpp/executors/single_threaded_executor.hpp"
-
-namespace rclcpp
-{
-namespace executors
-{
-
-/// Static executor implementation
-/**
- * This executor is a static version of the original single threaded executor.
- * It contains some performance optimization to avoid unnecessary reconstructions of
- * the executable list for every iteration.
- * All nodes, callbackgroups, timers, subscriptions etc. are created before
- * spin() is called, and modified only when an entity is added/removed to/from a node.
- * This executor is deprecated because these performance improvements have now been
- * applied to all other executors.
- * This executor is also considered unstable due to known bugs.
- * See the unit-tests that are only applied to `StandardExecutors` for information
- * on the known limitations.
- *
- * To run this executor instead of SingleThreadedExecutor replace:
- * rclcpp::executors::SingleThreadedExecutor exec;
- * by
- * rclcpp::executors::StaticSingleThreadedExecutor exec;
- * in your source code and spin node(s) in the following way:
- * exec.add_node(node);
- * exec.spin();
- * exec.remove_node(node);
- */
-class [[deprecated("Use rclcpp::executors::SingleThreadedExecutor")]] StaticSingleThreadedExecutor
-  : public rclcpp::Executor
-{
-public:
-  RCLCPP_SMART_PTR_DEFINITIONS(StaticSingleThreadedExecutor)
-
-  /// Default constructor. See the default constructor for Executor.
-  RCLCPP_PUBLIC
-  explicit StaticSingleThreadedExecutor(
-    const rclcpp::ExecutorOptions & options = rclcpp::ExecutorOptions());
-
-  /// Default destructor.
-  RCLCPP_PUBLIC
-  virtual ~StaticSingleThreadedExecutor();
-
-  /// Static executor implementation of spin.
-  /**
-   * This function will block until work comes in, execute it, and keep blocking.
-   * It will only be interrupted by a CTRL-C (managed by the global signal handler).
-   * \throws std::runtime_error when spin() called while already spinning
-   */
-  RCLCPP_PUBLIC
-  void
-  spin() override;
-
-  /// Static executor implementation of spin some
-  /**
-   * This non-blocking function will execute entities that
-   * were ready when this API was called, until timeout or no
-   * more work available. Entities that got ready while
-   * executing work, won't be taken into account here.
-   *
-   * Example:
-   *   while(condition) {
-   *     spin_some();
-   *     sleep(); // User should have some sync work or
-   *              // sleep to avoid a 100% CPU usage
-   *   }
-   */
-  RCLCPP_PUBLIC
-  void
-  spin_some(std::chrono::nanoseconds max_duration = std::chrono::nanoseconds(0)) override;
-
-  /// Static executor implementation of spin all
-  /**
-   * This non-blocking function will execute entities until timeout (must be >= 0)
-   * or no more work available.
-   * If timeout is `0`, potentially it blocks forever until no more work is available.
-   * If new entities get ready while executing work available, they will be executed
-   * as long as the timeout hasn't expired.
-   *
-   * Example:
-   *   while(condition) {
-   *     spin_all();
-   *     sleep(); // User should have some sync work or
-   *              // sleep to avoid a 100% CPU usage
-   *   }
-   */
-  RCLCPP_PUBLIC
-  void
-  spin_all(std::chrono::nanoseconds max_duration) override;
-
-protected:
-  /**
-   * @brief Executes ready executables from wait set.
-   * @param collection entities to evaluate for ready executables.
-   * @param wait_result result to check for ready executables.
-   * @param spin_once if true executes only the first ready executable.
-   * @return true if any executable was ready.
-   */
-  bool
-  execute_ready_executables(
-    const rclcpp::executors::ExecutorEntitiesCollection & collection,
-    rclcpp::WaitResult<rclcpp::WaitSet> & wait_result,
-    bool spin_once);
-
-  void
-  spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive);
-
-  void
-  spin_once_impl(std::chrono::nanoseconds timeout) override;
-
-  std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
-  collect_and_wait(std::chrono::nanoseconds timeout);
-
-private:
-  RCLCPP_DISABLE_COPY(StaticSingleThreadedExecutor)
-};
-
-}  // namespace executors
-}  // namespace rclcpp
-
-#endif  // RCLCPP__EXECUTORS__STATIC_SINGLE_THREADED_EXECUTOR_HPP_

rclcpp/include/rclcpp/experimental/buffers/ring_buffer_implementation.hpp

@@ -17,7 +17,6 @@
 
 #include <memory>
 #include <mutex>
-#include <shared_mutex>
 #include <stdexcept>
 #include <utility>
 #include <vector>
@@ -70,7 +69,7 @@ public:
    */
   void enqueue(BufferT request) override
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
 
     write_index_ = next_(write_index_);
     ring_buffer_[write_index_] = std::move(request);
@@ -96,7 +95,7 @@ public:
    */
   BufferT dequeue() override
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
 
     if (!has_data_()) {
       return BufferT();
@@ -135,7 +134,7 @@ public:
    */
   inline size_t next(size_t val)
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     return next_(val);
   }
 
@@ -147,7 +146,7 @@ public:
    */
   inline bool has_data() const override
   {
-    std::shared_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     return has_data_();
   }
 
@@ -160,7 +159,7 @@ public:
    */
   inline bool is_full() const
   {
-    std::shared_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     return is_full_();
   }
 
@@ -172,14 +171,14 @@ public:
    */
   size_t available_capacity() const override
   {
-    std::shared_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     return available_capacity_();
   }
 
   void clear() override
   {
     TRACETOOLS_TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     clear_();
   }
 
@@ -262,13 +261,17 @@ private:
     void> * = nullptr>
   std::vector<BufferT> get_all_data_impl()
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     std::vector<BufferT> result_vtr;
     result_vtr.reserve(size_);
     for (size_t id = 0; id < size_; ++id) {
-      result_vtr.emplace_back(
-        new typename is_std_unique_ptr<T>::Ptr_type(
-          *(ring_buffer_[(read_index_ + id) % capacity_])));
+      const auto & elem(ring_buffer_[(read_index_ + id) % capacity_]);
+      if (elem != nullptr) {
+        result_vtr.emplace_back(new typename is_std_unique_ptr<T>::Ptr_type(
+          *elem));
+      } else {
+        result_vtr.emplace_back(nullptr);
+      }
     }
     return result_vtr;
   }
@@ -277,7 +280,7 @@ private:
       std::is_copy_constructible<T>::value, void> * = nullptr>
   std::vector<BufferT> get_all_data_impl()
   {
-    std::unique_lock lock(mutex_);
+    std::lock_guard<std::mutex> lock(mutex_);
     std::vector<BufferT> result_vtr;
     result_vtr.reserve(size_);
     for (size_t id = 0; id < size_; ++id) {
@@ -311,7 +314,7 @@ private:
   size_t read_index_;
   size_t size_;
 
-  mutable std::shared_mutex mutex_;
+  mutable std::mutex mutex_;
 };
 
 }  // namespace buffers

rclcpp/include/rclcpp/experimental/executors/events_executor/events_executor.hpp

@@ -64,17 +64,17 @@ public:
 
   /// Default constructor. See the default constructor for Executor.
   /**
+   * \param[in] options Options used to configure the executor.
    * \param[in] events_queue The queue used to store events.
    * \param[in] execute_timers_separate_thread If true, timers are executed in a separate
    * thread. If false, timers are executed in the same thread as all other entities.
-   * \param[in] options Options used to configure the executor.
    */
   RCLCPP_PUBLIC
   EventsExecutor(
+    const rclcpp::ExecutorOptions & options = rclcpp::ExecutorOptions(),
     rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue = std::make_unique<
       rclcpp::experimental::executors::SimpleEventsQueue>(),
-    bool execute_timers_separate_thread = false,
-    const rclcpp::ExecutorOptions & options = rclcpp::ExecutorOptions());
+    bool execute_timers_separate_thread = false);
 
   /// Default destructor.
   RCLCPP_PUBLIC

rclcpp/include/rclcpp/graph_listener.hpp

@@ -154,6 +154,12 @@ public:
   bool
   is_shutdown();
 
+  /// Return true if the graph listener was started.
+  RCLCPP_PUBLIC
+  virtual
+  bool
+  is_started();
+
 protected:
   /// Main function for the listening thread.
   RCLCPP_PUBLIC
@@ -181,7 +187,6 @@ private:
   void
   __shutdown();
 
-  std::weak_ptr<rclcpp::Context> weak_parent_context_;
   std::shared_ptr<rcl_context_t> rcl_parent_context_;
 
   std::thread listener_thread_;

rclcpp/include/rclcpp/logging.hpp

@@ -0,0 +1,983 @@
+// Copyright 2017 Open Source Robotics Foundation, Inc.
+//
+// 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 RCLCPP__LOGGING_HPP_
+#define RCLCPP__LOGGING_HPP_
+
+#include <sstream>
+#include <type_traits>
+
+#include "rclcpp/logger.hpp"
+#include "rcutils/logging_macros.h"
+
+// These are used for compiling out logging macros lower than a minimum severity.
+#define RCLCPP_LOG_MIN_SEVERITY_DEBUG 0
+#define RCLCPP_LOG_MIN_SEVERITY_INFO 1
+#define RCLCPP_LOG_MIN_SEVERITY_WARN 2
+#define RCLCPP_LOG_MIN_SEVERITY_ERROR 3
+#define RCLCPP_LOG_MIN_SEVERITY_FATAL 4
+#define RCLCPP_LOG_MIN_SEVERITY_NONE 5
+
+#define RCLCPP_STATIC_ASSERT_LOGGER(logger) \
+  do { \
+    static_assert( \
+      ::std::is_convertible_v<decltype(logger), ::rclcpp::Logger>, \
+      "First argument to logging macros must be an rclcpp::Logger"); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG
+ * Log a message with given severity.
+ * \param logger The `rclcpp::Logger` to use
+ * \param ... The format string, followed by the variable arguments for the format string.
+ */
+#define RCLCPP_LOG(severity, logger, ...) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    RCUTILS_LOG_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_ONCE
+ * Log a message with given severity with the following condition:
+ * - All log calls except the first one are ignored.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param ... The format string, followed by the variable arguments for the format string.
+ */
+#define RCLCPP_LOG_ONCE(severity, logger, ...) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    RCUTILS_LOG_ONCE_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_EXPRESSION
+ * Log a message with given severity with the following condition:
+ * - Log calls are ignored when the expression evaluates to false.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param expression The expression determining if the message should be logged
+ * \param ... The format string, followed by the variable arguments for the format string.
+ */
+#define RCLCPP_LOG_EXPRESSION(severity, logger, expression, ...) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    RCUTILS_LOG_EXPRESSION_NAMED(severity, expression, (logger).get_name(), __VA_ARGS__); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_FUNCTION
+ * Log a message with given severity with the following condition:
+ * - Log calls are ignored when the function returns false.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param function The functions return value determines if the message should be logged
+ * \param ... The format string, followed by the variable arguments for the format string.
+ */
+#define RCLCPP_LOG_FUNCTION(severity, logger, function, ...) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    RCUTILS_LOG_FUNCTION_NAMED(severity, function, (logger).get_name(), __VA_ARGS__); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_SKIPFIRST
+ * Log a message with given severity with the following condition:
+ * - The first log call is ignored but all subsequent calls are processed.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param ... The format string, followed by the variable arguments for the format string.
+ */
+#define RCLCPP_LOG_SKIPFIRST(severity, logger, ...) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    RCUTILS_LOG_SKIPFIRST_NAMED(severity, (logger).get_name(), __VA_ARGS__); \
+  } while (0)
+
+#define RCLCPP_LOG_TIME_POINT_FUNC(clock) \
+  [&c = clock](rcutils_time_point_value_t * time_point)->rcutils_ret_t { \
+    try { \
+      *time_point = c.now().nanoseconds(); \
+    } catch (...) { \
+      RCUTILS_SAFE_FWRITE_TO_STDERR( \
+      "[rclcpp|logging.hpp] RCLCPP_DEBUG_THROTTLE could not get current time stamp\n"); \
+      return RCUTILS_RET_ERROR; \
+    } \
+    return RCUTILS_RET_OK; \
+  }
+
+/**
+ * \def RCLCPP_LOG_THROTTLE
+ * Log a message with given severity with the following condition:
+ * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param clock rclcpp::Clock that will be used to get the time point.
+ * \param duration The duration of the throttle interval as an integral value in milliseconds.
+ * \param ... The format string, followed by the variable arguments for the format string.
+ */
+#define RCLCPP_LOG_THROTTLE(severity, logger, clock, duration, ...) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    RCUTILS_LOG_THROTTLE_NAMED( \
+      severity, \
+      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
+      duration, \
+      (logger).get_name(), \
+      __VA_ARGS__); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_SKIPFIRST_THROTTLE
+ * Log a message with given severity with the following conditions:
+ * - The first log call is ignored but all subsequent calls are processed.
+ * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param clock rclcpp::Clock that will be used to get the time point.
+ * \param duration The duration of the throttle interval as an integral value in milliseconds.
+ * \param ... The format string, followed by the variable arguments for the format string.
+ */
+#define RCLCPP_LOG_SKIPFIRST_THROTTLE(severity, logger, clock, duration, ...) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    RCUTILS_LOG_SKIPFIRST_THROTTLE_NAMED( \
+      severity, \
+      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
+      duration, \
+      (logger).get_name(), \
+      __VA_ARGS__); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_STREAM
+ * Log a message with given severity.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param stream_arg The argument << into a stringstream
+ */
+#define RCLCPP_LOG_STREAM(severity, logger, stream_arg) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << stream_arg; \
+    RCUTILS_LOG_NAMED(severity, (logger).get_name(), "%s", rclcpp_stream_ss_.str().c_str()); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_STREAM_ONCE
+ * Log a message with given severity with the following condition:
+ * - All log calls except the first one are ignored.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param stream_arg The argument << into a stringstream
+ */
+#define RCLCPP_LOG_STREAM_ONCE(severity, logger, stream_arg) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << stream_arg; \
+    RCUTILS_LOG_ONCE_NAMED(severity, (logger).get_name(), "%s", rclcpp_stream_ss_.str().c_str()); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_STREAM_EXPRESSION
+ * Log a message with given severity with the following condition:
+ * - Log calls are being ignored when the expression evaluates to false.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param expression The expression determining if the message should be logged
+ * \param stream_arg The argument << into a stringstream
+ */
+#define RCLCPP_LOG_STREAM_EXPRESSION(severity, logger, expression, stream_arg) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << stream_arg; \
+    RCUTILS_LOG_EXPRESSION_NAMED( \
+      severity, \
+      expression, \
+      (logger).get_name(), \
+      "%s", rclcpp_stream_ss_.str().c_str()); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_STREAM_FUNCTION
+ * Log a message with given severity with the following condition:
+ * - Log calls are being ignored when the function returns false.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param function The functions return value determines if the message should be logged
+ * \param stream_arg The argument << into a stringstream
+ */
+#define RCLCPP_LOG_STREAM_FUNCTION(severity, logger, function, stream_arg) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << stream_arg; \
+    RCUTILS_LOG_FUNCTION_NAMED( \
+      severity, \
+      function, \
+      (logger).get_name(), \
+      "%s", rclcpp_stream_ss_.str().c_str()); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_STREAM_SKIPFIRST
+ * Log a message with given severity with the following condition:
+ * - The first log call is ignored but all subsequent calls are processed.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param stream_arg The argument << into a stringstream
+ */
+#define RCLCPP_LOG_STREAM_SKIPFIRST(severity, logger, stream_arg) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << stream_arg; \
+    RCUTILS_LOG_SKIPFIRST_NAMED( \
+      severity, \
+      (logger).get_name(), \
+      "%s", rclcpp_stream_ss_.str().c_str()); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_STREAM_THROTTLE
+ * Log a message with given severity with the following condition:
+ * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param clock rclcpp::Clock that will be used to get the time point.
+ * \param duration The duration of the throttle interval as an integral value in milliseconds.
+ * \param stream_arg The argument << into a stringstream
+ */
+#define RCLCPP_LOG_STREAM_THROTTLE(severity, logger, clock, duration, stream_arg) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << stream_arg; \
+    RCUTILS_LOG_THROTTLE_NAMED( \
+      severity, \
+      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
+      duration, \
+      (logger).get_name(), \
+      "%s", rclcpp_stream_ss_.str().c_str()); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
+ * Log a message with given severity with the following conditions:
+ * - The first log call is ignored but all subsequent calls are processed.
+ * - Log calls are ignored if the last logged message is not longer ago than the specified duration.
+ *
+ * \param logger The `rclcpp::Logger` to use
+ * \param clock rclcpp::Clock that will be used to get the time point.
+ * \param duration The duration of the throttle interval as an integral value in milliseconds.
+ * \param stream_arg The argument << into a stringstream
+ */
+#define RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(severity, logger, clock, duration, stream_arg) \
+  do { \
+    RCLCPP_STATIC_ASSERT_LOGGER(logger); \
+    std::stringstream rclcpp_stream_ss_; \
+    rclcpp_stream_ss_ << stream_arg; \
+    RCUTILS_LOG_SKIPFIRST_THROTTLE_NAMED( \
+      severity, \
+      RCLCPP_LOG_TIME_POINT_FUNC(clock), \
+      duration, \
+      (logger).get_name(), \
+      "%s", rclcpp_stream_ss_.str().c_str()); \
+  } while (0)
+
+/**
+ * \def RCLCPP_LOG_MIN_SEVERITY
+ * Define RCLCPP_LOG_MIN_SEVERITY=RCLCPP_LOG_MIN_SEVERITY_[DEBUG|INFO|WARN|ERROR|FATAL]
+ * in your build options to compile out anything below that severity.
+ * Use RCLCPP_LOG_MIN_SEVERITY_NONE to compile out all macros.
+ */
+#ifndef RCLCPP_LOG_MIN_SEVERITY
+#define RCLCPP_LOG_MIN_SEVERITY RCLCPP_LOG_MIN_SEVERITY_DEBUG
+#endif
+
+/** @name Logging macros for severity DEBUG.
+ */
+#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_DEBUG)
+// empty logging macros for severity DEBUG when being disabled at compile time
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_SKIPFIRST_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_STREAM(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_STREAM_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_STREAM_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_STREAM_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_STREAM_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_STREAM_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE(...)
+
+#else
+/**
+ * \def RCLCPP_DEBUG
+ * \copydoc RCLCPP_LOG
+ */
+#define RCLCPP_DEBUG(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_DEBUG_ONCE
+ * \copydoc RCLCPP_LOG_ONCE
+ */
+#define RCLCPP_DEBUG_ONCE(logger, ...) \
+  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_DEBUG_EXPRESSION
+ * \copydoc RCLCPP_LOG_EXPRESSION
+ */
+#define RCLCPP_DEBUG_EXPRESSION(logger, expression, ...) \
+  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_DEBUG, logger, expression, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_DEBUG_FUNCTION
+ * \copydoc RCLCPP_LOG_FUNCTION
+ */
+#define RCLCPP_DEBUG_FUNCTION(logger, function, ...) \
+  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_DEBUG, logger, function, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_DEBUG_SKIPFIRST
+ * \copydoc RCLCPP_LOG_SKIPFIRST
+ */
+#define RCLCPP_DEBUG_SKIPFIRST(logger, ...) \
+  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_DEBUG, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_DEBUG_THROTTLE
+ * \copydoc RCLCPP_LOG_THROTTLE
+ */
+#define RCLCPP_DEBUG_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_DEBUG_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_DEBUG_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_DEBUG_STREAM
+ * \copydoc RCLCPP_LOG_STREAM
+ */
+#define RCLCPP_DEBUG_STREAM(logger, stream_arg) \
+  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)
+
+/**
+ * \def RCLCPP_DEBUG_STREAM_ONCE
+ * \copydoc RCLCPP_LOG_STREAM_ONCE
+ */
+#define RCLCPP_DEBUG_STREAM_ONCE(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)
+
+/**
+ * \def RCLCPP_DEBUG_STREAM_EXPRESSION
+ * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
+ */
+#define RCLCPP_DEBUG_STREAM_EXPRESSION(logger, expression, stream_arg) \
+  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_DEBUG, logger, expression, stream_arg)
+
+/**
+ * \def RCLCPP_DEBUG_STREAM_FUNCTION
+ * \copydoc RCLCPP_LOG_STREAM_FUNCTION
+ */
+#define RCLCPP_DEBUG_STREAM_FUNCTION(logger, function, stream_arg) \
+  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_DEBUG, logger, function, stream_args)
+
+/**
+ * \def RCLCPP_DEBUG_STREAM_SKIPFIRST
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
+ */
+#define RCLCPP_DEBUG_STREAM_SKIPFIRST(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_DEBUG, logger, stream_arg)
+
+/**
+ * \def RCLCPP_DEBUG_STREAM_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_THROTTLE
+ */
+#define RCLCPP_DEBUG_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, stream_arg)
+
+/**
+ * \def RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_DEBUG_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_DEBUG, logger, clock, duration, \
+    stream_arg)
+
+#endif
+
+/** @name Logging macros for severity INFO.
+ */
+#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_INFO)
+// empty logging macros for severity INFO when being disabled at compile time
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_SKIPFIRST_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_STREAM(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_STREAM_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_STREAM_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_STREAM_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_STREAM_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_STREAM_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE(...)
+
+#else
+/**
+ * \def RCLCPP_INFO
+ * \copydoc RCLCPP_LOG
+ */
+#define RCLCPP_INFO(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_INFO_ONCE
+ * \copydoc RCLCPP_LOG_ONCE
+ */
+#define RCLCPP_INFO_ONCE(logger, ...) \
+  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_INFO_EXPRESSION
+ * \copydoc RCLCPP_LOG_EXPRESSION
+ */
+#define RCLCPP_INFO_EXPRESSION(logger, expression, ...) \
+  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_INFO, logger, expression, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_INFO_FUNCTION
+ * \copydoc RCLCPP_LOG_FUNCTION
+ */
+#define RCLCPP_INFO_FUNCTION(logger, function, ...) \
+  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_INFO, logger, function, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_INFO_SKIPFIRST
+ * \copydoc RCLCPP_LOG_SKIPFIRST
+ */
+#define RCLCPP_INFO_SKIPFIRST(logger, ...) \
+  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_INFO, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_INFO_THROTTLE
+ * \copydoc RCLCPP_LOG_THROTTLE
+ */
+#define RCLCPP_INFO_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_INFO_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_INFO_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_INFO_STREAM
+ * \copydoc RCLCPP_LOG_STREAM
+ */
+#define RCLCPP_INFO_STREAM(logger, stream_arg) \
+  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)
+
+/**
+ * \def RCLCPP_INFO_STREAM_ONCE
+ * \copydoc RCLCPP_LOG_STREAM_ONCE
+ */
+#define RCLCPP_INFO_STREAM_ONCE(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)
+
+/**
+ * \def RCLCPP_INFO_STREAM_EXPRESSION
+ * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
+ */
+#define RCLCPP_INFO_STREAM_EXPRESSION(logger, expression, stream_arg) \
+  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_INFO, logger, expression, stream_arg)
+
+/**
+ * \def RCLCPP_INFO_STREAM_FUNCTION
+ * \copydoc RCLCPP_LOG_STREAM_FUNCTION
+ */
+#define RCLCPP_INFO_STREAM_FUNCTION(logger, function, stream_arg) \
+  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_INFO, logger, function, stream_args)
+
+/**
+ * \def RCLCPP_INFO_STREAM_SKIPFIRST
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
+ */
+#define RCLCPP_INFO_STREAM_SKIPFIRST(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_INFO, logger, stream_arg)
+
+/**
+ * \def RCLCPP_INFO_STREAM_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_THROTTLE
+ */
+#define RCLCPP_INFO_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, stream_arg)
+
+/**
+ * \def RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_INFO_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_INFO, logger, clock, duration, \
+    stream_arg)
+
+#endif
+
+/** @name Logging macros for severity WARN.
+ */
+#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_WARN)
+// empty logging macros for severity WARN when being disabled at compile time
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_SKIPFIRST_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_STREAM(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_STREAM_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_STREAM_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_STREAM_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_STREAM_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_STREAM_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE(...)
+
+#else
+/**
+ * \def RCLCPP_WARN
+ * \copydoc RCLCPP_LOG
+ */
+#define RCLCPP_WARN(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_WARN_ONCE
+ * \copydoc RCLCPP_LOG_ONCE
+ */
+#define RCLCPP_WARN_ONCE(logger, ...) \
+  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_WARN_EXPRESSION
+ * \copydoc RCLCPP_LOG_EXPRESSION
+ */
+#define RCLCPP_WARN_EXPRESSION(logger, expression, ...) \
+  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_WARN, logger, expression, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_WARN_FUNCTION
+ * \copydoc RCLCPP_LOG_FUNCTION
+ */
+#define RCLCPP_WARN_FUNCTION(logger, function, ...) \
+  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_WARN, logger, function, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_WARN_SKIPFIRST
+ * \copydoc RCLCPP_LOG_SKIPFIRST
+ */
+#define RCLCPP_WARN_SKIPFIRST(logger, ...) \
+  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_WARN, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_WARN_THROTTLE
+ * \copydoc RCLCPP_LOG_THROTTLE
+ */
+#define RCLCPP_WARN_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_WARN_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_WARN_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_WARN_STREAM
+ * \copydoc RCLCPP_LOG_STREAM
+ */
+#define RCLCPP_WARN_STREAM(logger, stream_arg) \
+  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)
+
+/**
+ * \def RCLCPP_WARN_STREAM_ONCE
+ * \copydoc RCLCPP_LOG_STREAM_ONCE
+ */
+#define RCLCPP_WARN_STREAM_ONCE(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)
+
+/**
+ * \def RCLCPP_WARN_STREAM_EXPRESSION
+ * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
+ */
+#define RCLCPP_WARN_STREAM_EXPRESSION(logger, expression, stream_arg) \
+  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_WARN, logger, expression, stream_arg)
+
+/**
+ * \def RCLCPP_WARN_STREAM_FUNCTION
+ * \copydoc RCLCPP_LOG_STREAM_FUNCTION
+ */
+#define RCLCPP_WARN_STREAM_FUNCTION(logger, function, stream_arg) \
+  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_WARN, logger, function, stream_args)
+
+/**
+ * \def RCLCPP_WARN_STREAM_SKIPFIRST
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
+ */
+#define RCLCPP_WARN_STREAM_SKIPFIRST(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_WARN, logger, stream_arg)
+
+/**
+ * \def RCLCPP_WARN_STREAM_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_THROTTLE
+ */
+#define RCLCPP_WARN_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, stream_arg)
+
+/**
+ * \def RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_WARN_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_WARN, logger, clock, duration, \
+    stream_arg)
+
+#endif
+
+/** @name Logging macros for severity ERROR.
+ */
+#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_ERROR)
+// empty logging macros for severity ERROR when being disabled at compile time
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_SKIPFIRST_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_STREAM(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_STREAM_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_STREAM_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_STREAM_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_STREAM_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_STREAM_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE(...)
+
+#else
+/**
+ * \def RCLCPP_ERROR
+ * \copydoc RCLCPP_LOG
+ */
+#define RCLCPP_ERROR(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_ERROR_ONCE
+ * \copydoc RCLCPP_LOG_ONCE
+ */
+#define RCLCPP_ERROR_ONCE(logger, ...) \
+  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_ERROR_EXPRESSION
+ * \copydoc RCLCPP_LOG_EXPRESSION
+ */
+#define RCLCPP_ERROR_EXPRESSION(logger, expression, ...) \
+  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_ERROR, logger, expression, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_ERROR_FUNCTION
+ * \copydoc RCLCPP_LOG_FUNCTION
+ */
+#define RCLCPP_ERROR_FUNCTION(logger, function, ...) \
+  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_ERROR, logger, function, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_ERROR_SKIPFIRST
+ * \copydoc RCLCPP_LOG_SKIPFIRST
+ */
+#define RCLCPP_ERROR_SKIPFIRST(logger, ...) \
+  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_ERROR, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_ERROR_THROTTLE
+ * \copydoc RCLCPP_LOG_THROTTLE
+ */
+#define RCLCPP_ERROR_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_ERROR_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_ERROR_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_ERROR_STREAM
+ * \copydoc RCLCPP_LOG_STREAM
+ */
+#define RCLCPP_ERROR_STREAM(logger, stream_arg) \
+  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)
+
+/**
+ * \def RCLCPP_ERROR_STREAM_ONCE
+ * \copydoc RCLCPP_LOG_STREAM_ONCE
+ */
+#define RCLCPP_ERROR_STREAM_ONCE(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)
+
+/**
+ * \def RCLCPP_ERROR_STREAM_EXPRESSION
+ * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
+ */
+#define RCLCPP_ERROR_STREAM_EXPRESSION(logger, expression, stream_arg) \
+  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_ERROR, logger, expression, stream_arg)
+
+/**
+ * \def RCLCPP_ERROR_STREAM_FUNCTION
+ * \copydoc RCLCPP_LOG_STREAM_FUNCTION
+ */
+#define RCLCPP_ERROR_STREAM_FUNCTION(logger, function, stream_arg) \
+  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_ERROR, logger, function, stream_args)
+
+/**
+ * \def RCLCPP_ERROR_STREAM_SKIPFIRST
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
+ */
+#define RCLCPP_ERROR_STREAM_SKIPFIRST(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_ERROR, logger, stream_arg)
+
+/**
+ * \def RCLCPP_ERROR_STREAM_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_THROTTLE
+ */
+#define RCLCPP_ERROR_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, stream_arg)
+
+/**
+ * \def RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_ERROR_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_ERROR, logger, clock, duration, \
+    stream_arg)
+
+#endif
+
+/** @name Logging macros for severity FATAL.
+ */
+#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_FATAL)
+// empty logging macros for severity FATAL when being disabled at compile time
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_SKIPFIRST_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_STREAM(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_STREAM_ONCE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_STREAM_EXPRESSION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_STREAM_FUNCTION(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_STREAM_SKIPFIRST(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_STREAM_THROTTLE(...)
+/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
+#define RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE(...)
+
+#else
+/**
+ * \def RCLCPP_FATAL
+ * \copydoc RCLCPP_LOG
+ */
+#define RCLCPP_FATAL(logger, ...) RCLCPP_LOG(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_FATAL_ONCE
+ * \copydoc RCLCPP_LOG_ONCE
+ */
+#define RCLCPP_FATAL_ONCE(logger, ...) \
+  RCLCPP_LOG_ONCE(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_FATAL_EXPRESSION
+ * \copydoc RCLCPP_LOG_EXPRESSION
+ */
+#define RCLCPP_FATAL_EXPRESSION(logger, expression, ...) \
+  RCLCPP_LOG_EXPRESSION(RCUTILS_LOG_SEVERITY_FATAL, logger, expression, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_FATAL_FUNCTION
+ * \copydoc RCLCPP_LOG_FUNCTION
+ */
+#define RCLCPP_FATAL_FUNCTION(logger, function, ...) \
+  RCLCPP_LOG_FUNCTION(RCUTILS_LOG_SEVERITY_FATAL, logger, function, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_FATAL_SKIPFIRST
+ * \copydoc RCLCPP_LOG_SKIPFIRST
+ */
+#define RCLCPP_FATAL_SKIPFIRST(logger, ...) \
+  RCLCPP_LOG_SKIPFIRST(RCUTILS_LOG_SEVERITY_FATAL, logger, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_FATAL_THROTTLE
+ * \copydoc RCLCPP_LOG_THROTTLE
+ */
+#define RCLCPP_FATAL_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_FATAL_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_FATAL_SKIPFIRST_THROTTLE(logger, clock, duration, ...) \
+  RCLCPP_LOG_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, __VA_ARGS__)
+
+/**
+ * \def RCLCPP_FATAL_STREAM
+ * \copydoc RCLCPP_LOG_STREAM
+ */
+#define RCLCPP_FATAL_STREAM(logger, stream_arg) \
+  RCLCPP_LOG_STREAM(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)
+
+/**
+ * \def RCLCPP_FATAL_STREAM_ONCE
+ * \copydoc RCLCPP_LOG_STREAM_ONCE
+ */
+#define RCLCPP_FATAL_STREAM_ONCE(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_ONCE(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)
+
+/**
+ * \def RCLCPP_FATAL_STREAM_EXPRESSION
+ * \copydoc RCLCPP_LOG_STREAM_EXPRESSION
+ */
+#define RCLCPP_FATAL_STREAM_EXPRESSION(logger, expression, stream_arg) \
+  RCLCPP_LOG_STREAM_EXPRESSION(RCUTILS_LOG_SEVERITY_FATAL, logger, expression, stream_arg)
+
+/**
+ * \def RCLCPP_FATAL_STREAM_FUNCTION
+ * \copydoc RCLCPP_LOG_STREAM_FUNCTION
+ */
+#define RCLCPP_FATAL_STREAM_FUNCTION(logger, function, stream_arg) \
+  RCLCPP_LOG_STREAM_FUNCTION(RCUTILS_LOG_SEVERITY_FATAL, logger, function, stream_args)
+
+/**
+ * \def RCLCPP_FATAL_STREAM_SKIPFIRST
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST
+ */
+#define RCLCPP_FATAL_STREAM_SKIPFIRST(logger, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST(RCUTILS_LOG_SEVERITY_FATAL, logger, stream_arg)
+
+/**
+ * \def RCLCPP_FATAL_STREAM_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_THROTTLE
+ */
+#define RCLCPP_FATAL_STREAM_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, stream_arg)
+
+/**
+ * \def RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE
+ * \copydoc RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE
+ */
+#define RCLCPP_FATAL_STREAM_SKIPFIRST_THROTTLE(logger, clock, duration, stream_arg) \
+  RCLCPP_LOG_STREAM_SKIPFIRST_THROTTLE(RCUTILS_LOG_SEVERITY_FATAL, logger, clock, duration, \
+    stream_arg)
+
+#endif
+
+#endif  // RCLCPP__LOGGING_HPP_

rclcpp/include/rclcpp/node_interfaces/node_base.hpp

@@ -121,11 +121,6 @@ public:
   std::atomic_bool &
   get_associated_with_executor_atomic() override;
 
-  [[deprecated("Use get_shared_notify_guard_condition or trigger_notify_guard_condition instead")]]
-  RCLCPP_PUBLIC
-  rclcpp::GuardCondition &
-  get_notify_guard_condition() override;
-
   RCLCPP_PUBLIC
   rclcpp::GuardCondition::SharedPtr
   get_shared_notify_guard_condition() override;

rclcpp/include/rclcpp/node_interfaces/node_base_interface.hpp

@@ -144,17 +144,6 @@ public:
   std::atomic_bool &
   get_associated_with_executor_atomic() = 0;
 
-  /// Return a guard condition that should be notified when the internal node state changes.
-  /**
-   * For example, this should be notified when a publisher is added or removed.
-   *
-   * \return the GuardCondition if it is valid, else throw runtime error
-   */
-  RCLCPP_PUBLIC
-  virtual
-  rclcpp::GuardCondition &
-  get_notify_guard_condition() = 0;
-
   /// Return a guard condition that should be notified when the internal node state changes.
   /**
    * For example, this should be notified when a publisher is added or removed.

rclcpp/include/rclcpp/node_interfaces/node_graph.hpp

@@ -165,8 +165,6 @@ private:
   /// Handle to the NodeBaseInterface given in the constructor.
   rclcpp::node_interfaces::NodeBaseInterface * node_base_;
 
-  /// Graph Listener which waits on graph changes for the node and is shared across nodes.
-  std::shared_ptr<rclcpp::graph_listener::GraphListener> graph_listener_;
   /// Whether or not this node needs to be added to the graph listener.
   std::atomic_bool should_add_to_graph_listener_;
 

rclcpp/include/rclcpp/node_options.hpp

@@ -146,6 +146,14 @@ public:
     return *this;
   }
 
+  /// Append a single parameter override, parameter idiom style.
+  NodeOptions &
+  append_parameter_override(const rclcpp::Parameter & param)
+  {
+    this->parameter_overrides().push_back(param);
+    return *this;
+  }
+
   /// Return the use_global_arguments flag.
   RCLCPP_PUBLIC
   bool

rclcpp/include/rclcpp/publisher.hpp

@@ -574,6 +574,13 @@ protected:
   std::unique_ptr<PublishedType, PublishedTypeDeleter>
   duplicate_type_adapt_message_as_unique_ptr(const PublishedType & msg)
   {
+    /// Assert that the published type has no overloaded operator new since this leads to
+    /// new/delete mismatch (see https://github.com/ros2/rclcpp/issues/2951)
+    static_assert(!detail::has_overloaded_operator_new_v<PublishedType>,
+        "When publishing by value (i.e. when calling publish(const T& msg)), the published "
+    "message type must not have an overloaded operator new. In this case, please use the "
+    "publish(std::unique_ptr<T> msg) method instead.");
+
     auto ptr = PublishedTypeAllocatorTraits::allocate(published_type_allocator_, 1);
     PublishedTypeAllocatorTraits::construct(published_type_allocator_, ptr, msg);
     return std::unique_ptr<PublishedType, PublishedTypeDeleter>(ptr, published_type_deleter_);

rclcpp/include/rclcpp/rclcpp.hpp

@@ -68,8 +68,6 @@
  *
  * - Executors (responsible for execution of callbacks through a blocking spin):
  *   - rclcpp::spin()
- *   - rclcpp::spin_some()
- *   - rclcpp::spin_until_future_complete()
  *   - rclcpp::executors::SingleThreadedExecutor
  *   - rclcpp::executors::SingleThreadedExecutor::add_node()
  *   - rclcpp::executors::SingleThreadedExecutor::spin()

rclcpp/include/rclcpp/time.hpp

@@ -33,12 +33,11 @@ class Time
 public:
   /// Time constructor
   /**
-   * Initializes the time values for seconds and nanoseconds individually.
-   * Large values for nanoseconds are wrapped automatically with the remainder added to seconds.
-   * Both inputs must be integers.
+   * Indicates a specific point in time, relative to a clock's 0 point (its epoch).
+   * The total time since the epoch is given by seconds + nanoseconds.
    *
-   * \param seconds part of the time in seconds since time epoch
-   * \param nanoseconds part of the time in nanoseconds since time epoch
+   * \param seconds the seconds component, valid only if positive
+   * \param nanoseconds the nanoseconds component, to be added to the seconds component
    * \param clock_type clock type
    * \throws std::runtime_error if seconds are negative
    */
@@ -47,7 +46,7 @@ public:
 
   /// Time constructor
   /**
-   * \param nanoseconds since time epoch
+   * \param nanoseconds the total time since the epoch in nanoseconds
    * \param clock_type clock type
    * \throws std::runtime_error if nanoseconds are negative
    */
@@ -190,7 +189,7 @@ public:
 
   /// Get the nanoseconds since epoch
   /**
-   * \return the nanoseconds since epoch as a rcl_time_point_value_t structure.
+   * \return the total time since the epoch in nanoseconds, as a rcl_time_point_value_t structure.
    */
   RCLCPP_PUBLIC
   rcl_time_point_value_t
@@ -209,7 +208,7 @@ public:
    * \warning Depending on sizeof(double) there could be significant precision loss.
    * When an exact time is required use nanoseconds() instead.
    *
-   * \return the seconds since epoch as a floating point number.
+   * \return the total time since the epoch in seconds, as a floating point number.
    */
   RCLCPP_PUBLIC
   double

rclcpp/include/rclcpp/type_adapter.hpp

@@ -16,6 +16,7 @@
 #define RCLCPP__TYPE_ADAPTER_HPP_
 
 #include <type_traits>
+#include <new>
 
 namespace rclcpp
 {
@@ -128,6 +129,24 @@ struct assert_type_pair_is_specialized_type_adapter
     "No type adapter for this custom type/ros message type pair");
 };
 
+template<typename, typename = void>
+struct has_overloaded_operator_new : std::false_type {};
+template<typename T>
+struct has_overloaded_operator_new<T, std::void_t<
+    decltype(T::operator new(std::size_t()))
+  >>: std::true_type {};
+
+template<typename, typename = void>
+struct has_overloaded_aligned_operator_new : std::false_type {};
+template<typename T>
+struct has_overloaded_aligned_operator_new<T,
+  std::void_t<decltype( T::operator new(std::size_t(), std::align_val_t()) )>>
+  : std::true_type {};
+
+template<typename T>
+inline constexpr bool has_overloaded_operator_new_v = has_overloaded_operator_new<T>::value ||
+  has_overloaded_aligned_operator_new<T>::value;
+
 }  // namespace detail
 
 /// Template metafunction that can make the type being adapted explicit.

rclcpp/include/rclcpp/typesupport_helpers.hpp

@@ -29,26 +29,48 @@
 
 namespace rclcpp
 {
-/// Load the type support library for the given type.
-/**
- * \param[in] type The topic type, e.g. "std_msgs/msg/String"
- * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
- * \return A shared library
- */
+
+/// \brief Extract the package name, middle module, and type name from a full type string.
+/// \details This function takes a full type string (e.g., "std_msgs/msg/String") and extracts
+/// the package name, middle module (if any), and type name. The middle module is the part
+/// between the package name and the type name, which is typically used for message types.
+/// For example, for "std_msgs/msg/String", it returns ("std_msgs", "msg", "String").
+/// \param[in] full_type
+/// \throws std::runtime_error if the input full type string is malformed or does not follow the
+/// expected format.
+/// \return A tuple containing the package name, middle module (if any), and type name.
+RCLCPP_PUBLIC
+std::tuple<std::string, std::string, std::string>
+extract_type_identifier(const std::string & full_type);
+
+/// \brief Look for the library in the ament prefix paths and return the path to the type support
+/// library.
+/// \param[in] package_name The name of the package containing the type support library,
+/// e.g. "std_msgs".
+/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+/// \throws std::runtime_error if the library is not found.
+/// \return The path to the type support library.
+RCLCPP_PUBLIC
+std::string get_typesupport_library_path(
+  const std::string & package_name, const std::string & typesupport_identifier);
+
+/// \brief Load the type support library for the given type.
+/// \param[in] type The topic type, e.g. "std_msgs/msg/String"
+/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+/// \throws std::runtime_error if the library is not found or cannot be loaded.
+/// \return A shared library
 RCLCPP_PUBLIC
 std::shared_ptr<rcpputils::SharedLibrary>
 get_typesupport_library(const std::string & type, const std::string & typesupport_identifier);
 
-/// Extract the message type support handle from the library.
-/**
- * The library needs to match the topic type. The shared library must stay loaded for the lifetime of the result.
- *
- * \param[in] type The topic type, e.g. "std_msgs/msg/String"
- * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
- * \param[in] library The shared type support library
- * \throws std::runtime_error if the symbol of type not found in the library.
- * \return A message type support handle
- */
+/// \brief Extracts the message type support handle from the library.
+/// \note The library needs to match the topic type. The shared library must stay loaded for the
+/// lifetime of the result.
+/// \param[in] type The topic type, e.g. "std_msgs/msg/String"
+/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+/// \param[in] library The shared type support library
+/// \throws std::runtime_error if the symbol of type not found in the library.
+/// \return A message type support handle
 RCLCPP_PUBLIC
 const rosidl_message_type_support_t *
 get_message_typesupport_handle(
@@ -56,16 +78,14 @@ get_message_typesupport_handle(
   const std::string & typesupport_identifier,
   rcpputils::SharedLibrary & library);
 
-/// Extract the service type support handle from the library.
-/**
- * The library needs to match the service type. The shared library must stay loaded for the lifetime of the result.
- *
- * \param[in] type The service type, e.g. "std_srvs/srv/Empty"
- * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
- * \param[in] library The shared type support library
- * \throws std::runtime_error if the symbol of type not found in the library.
- * \return A service type support handle
- */
+/// \brief Extracts the service type support handle from the library.
+/// \note The library needs to match the service type. The shared library must stay loaded for the
+/// lifetime of the result.
+/// \param[in] type The service type, e.g. "std_srvs/srv/Empty"
+/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+/// \param[in] library The shared type support library
+/// \throws std::runtime_error if the symbol of type not found in the library.
+/// \return A service type support handle
 RCLCPP_PUBLIC
 const rosidl_service_type_support_t *
 get_service_typesupport_handle(
@@ -73,17 +93,14 @@ get_service_typesupport_handle(
   const std::string & typesupport_identifier,
   rcpputils::SharedLibrary & library);
 
-/// Extract the action type support handle from the library.
-/**
- * The library needs to match the action type. The shared library must stay loaded for the lifetime
- * of the result.
- *
- * \param[in] type The action type, e.g. "example_interfaces/action/Fibonacci"
- * \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
- * \param[in] library The shared type support library
- * \throws std::runtime_error if the symbol of type not found in the library.
- * \return A action type support handle
- */
+/// \brief Extracts the action type support handle from the library.
+/// \note The library needs to match the action type. The shared library must stay loaded for the
+/// lifetime of the result.
+/// \param[in] type The action type, e.g. "example_interfaces/action/Fibonacci"
+/// \param[in] typesupport_identifier Type support identifier, typically "rosidl_typesupport_cpp"
+/// \param[in] library The shared type support library
+/// \throws std::runtime_error if the symbol of type not found in the library.
+/// \return A action type support handle
 RCLCPP_PUBLIC
 const rosidl_action_type_support_t *
 get_action_typesupport_handle(

rclcpp/include/rclcpp/wait_for_message.hpp

@@ -15,6 +15,7 @@
 #ifndef RCLCPP__WAIT_FOR_MESSAGE_HPP_
 #define RCLCPP__WAIT_FOR_MESSAGE_HPP_
 
+#include <future>
 #include <memory>
 #include <string>
 
@@ -23,6 +24,7 @@
 #include "rclcpp/node.hpp"
 #include "rclcpp/visibility_control.hpp"
 #include "rclcpp/wait_set.hpp"
+#include "rclcpp/qos.hpp"
 
 namespace rclcpp
 {
@@ -79,10 +81,11 @@ bool wait_for_message(
 /**
  * Wait for the next incoming message to arrive on a specified topic before the specified timeout.
  *
- * \param[out] out is the message to be filled when a new message is arriving.
+ * \param[out] out is the message to be filled when a new message is arriving
  * \param[in] node the node pointer to initialize the subscription on.
  * \param[in] topic the topic to wait for messages.
  * \param[in] time_to_wait parameter specifying the timeout before returning.
+ * \param[in] qos parameter specifying QoS settings for the subscription.
  * \return true if a message was successfully received, false if message could not
  * be obtained or shutdown was triggered asynchronously on the context.
  */
@@ -91,9 +94,10 @@ bool wait_for_message(
   MsgT & out,
   rclcpp::Node::SharedPtr node,
   const std::string & topic,
-  std::chrono::duration<Rep, Period> time_to_wait = std::chrono::duration<Rep, Period>(-1))
+  std::chrono::duration<Rep, Period> time_to_wait = std::chrono::duration<Rep, Period>(-1),
+  const rclcpp::QoS & qos = rclcpp::SystemDefaultsQoS())
 {
-  auto sub = node->create_subscription<MsgT>(topic, 1, [](const std::shared_ptr<const MsgT>) {});
+  auto sub = node->create_subscription<MsgT>(topic, qos, [](const std::shared_ptr<const MsgT>) {});
   return wait_for_message<MsgT, Rep, Period>(
     out, sub, node->get_node_options().context(), time_to_wait);
 }

rclcpp/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp</name>
-  <version>29.6.0</version>
+  <version>30.1.2</version>
   <description>The ROS client library in C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
@@ -17,6 +17,7 @@
   <buildtool_depend>ament_cmake_ros</buildtool_depend>
   <buildtool_depend>ament_cmake_gen_version_h</buildtool_depend>
   <buildtool_depend>python3</buildtool_depend>
+  <buildtool_depend>python3-empy</buildtool_depend>
 
   <build_depend>ament_index_cpp</build_depend>
   <build_depend>builtin_interfaces</build_depend>

rclcpp/resource/logging.hpp.em

@@ -1,165 +0,0 @@
-// generated from rclcpp/resource/logging.hpp.em
-
-// Copyright 2017 Open Source Robotics Foundation, Inc.
-//
-// 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 RCLCPP__LOGGING_HPP_
-#define RCLCPP__LOGGING_HPP_
-
-#include <sstream>
-#include <type_traits>
-
-#include "rclcpp/logger.hpp"
-#include "rcutils/logging_macros.h"
-#include "rclcpp/utilities.hpp"
-
-// These are used for compiling out logging macros lower than a minimum severity.
-#define RCLCPP_LOG_MIN_SEVERITY_DEBUG 0
-#define RCLCPP_LOG_MIN_SEVERITY_INFO 1
-#define RCLCPP_LOG_MIN_SEVERITY_WARN 2
-#define RCLCPP_LOG_MIN_SEVERITY_ERROR 3
-#define RCLCPP_LOG_MIN_SEVERITY_FATAL 4
-#define RCLCPP_LOG_MIN_SEVERITY_NONE 5
-
-#define RCLCPP_FIRST_ARG(N, ...) N
-#define RCLCPP_ALL_BUT_FIRST_ARGS(N, ...) __VA_ARGS__
-
-/**
- * \def RCLCPP_LOG_MIN_SEVERITY
- * Define RCLCPP_LOG_MIN_SEVERITY=RCLCPP_LOG_MIN_SEVERITY_[DEBUG|INFO|WARN|ERROR|FATAL]
- * in your build options to compile out anything below that severity.
- * Use RCLCPP_LOG_MIN_SEVERITY_NONE to compile out all macros.
- */
-#ifndef RCLCPP_LOG_MIN_SEVERITY
-#define RCLCPP_LOG_MIN_SEVERITY RCLCPP_LOG_MIN_SEVERITY_DEBUG
-#endif
-
-@{
-from collections import OrderedDict
-from copy import deepcopy
-from rcutils.logging import feature_combinations
-from rcutils.logging import get_suffix_from_features
-from rcutils.logging import severities
-from rcutils.logging import throttle_args
-from rcutils.logging import throttle_params
-
-throttle_args['condition_before'] = 'RCUTILS_LOG_CONDITION_THROTTLE_BEFORE(clock, duration)'
-del throttle_params['get_time_point_value']
-throttle_params['clock'] = 'rclcpp::Clock that will be used to get the time point.'
-throttle_params.move_to_end('clock', last=False)
-
-rclcpp_feature_combinations = OrderedDict()
-for combinations, feature in feature_combinations.items():
-    # skip feature combinations using 'named'
-    if 'named' in combinations:
-        continue
-    rclcpp_feature_combinations[combinations] = feature
-# add a stream variant for each available feature combination
-stream_arg = 'stream_arg'
-for combinations, feature in list(rclcpp_feature_combinations.items()):
-    combinations = ('stream', ) + combinations
-    feature = deepcopy(feature)
-    feature.params[stream_arg] = 'The argument << into a stringstream'
-    rclcpp_feature_combinations[combinations] = feature
-
-def get_rclcpp_suffix_from_features(features):
-    suffix = get_suffix_from_features(features)
-    if 'stream' in features:
-        suffix = '_STREAM' + suffix
-    return suffix
-}@
-@[for severity in severities]@
-/** @@name Logging macros for severity @(severity).
- */
-///@@{
-#if (RCLCPP_LOG_MIN_SEVERITY > RCLCPP_LOG_MIN_SEVERITY_@(severity))
-// empty logging macros for severity @(severity) when being disabled at compile time
-@[ for feature_combination in rclcpp_feature_combinations.keys()]@
-@{suffix = get_rclcpp_suffix_from_features(feature_combination)}@
-/// Empty logging macro due to the preprocessor definition of RCLCPP_LOG_MIN_SEVERITY.
-#define RCLCPP_@(severity)@(suffix)(...)
-@[ end for]@
-
-#else
-@[ for feature_combination in rclcpp_feature_combinations.keys()]@
-@{suffix = get_rclcpp_suffix_from_features(feature_combination)}@
-// The RCLCPP_@(severity)@(suffix) macro is surrounded by do { .. } while (0)
-// to implement the standard C macro idiom to make the macro safe in all
-// contexts; see http://c-faq.com/cpp/multistmt.html for more information.
-/**
- * \def RCLCPP_@(severity)@(suffix)
- * Log a message with severity @(severity)@
-@[ if rclcpp_feature_combinations[feature_combination].doc_lines]@
- with the following conditions:
-@[ else]@
-.
-@[ end if]@
-@[ for doc_line in rclcpp_feature_combinations[feature_combination].doc_lines]@
- * @(doc_line)
-@[ end for]@
- * \param logger The `rclcpp::Logger` to use
-@[ for param_name, doc_line in rclcpp_feature_combinations[feature_combination].params.items()]@
- * \param @(param_name) @(doc_line)
-@[ end for]@
-@[ if 'stream' not in feature_combination]@
- * \param ... The format string, followed by the variable arguments for the format string.
-@[ end if]@
- */
-@{params = rclcpp_feature_combinations[feature_combination].params.keys()}@
-#define RCLCPP_@(severity)@(suffix)(logger@(''.join([', ' + p for p in params]))@
-@[ if 'stream' not in feature_combination]@
-, ...@
-@[ end if]@
-) \
-  do { \
-    static_assert( \
-      ::std::is_same<typename std::remove_cv_t<typename std::remove_reference_t<decltype(logger)>>, \
-      typename ::rclcpp::Logger>::value, \
-      "First argument to logging macros must be an rclcpp::Logger"); \
-@[ if 'throttle' in feature_combination]@ \
-    auto get_time_point = [&c=clock](rcutils_time_point_value_t * time_point) -> rcutils_ret_t { \
-      try { \
-        *time_point = c.now().nanoseconds(); \
-      } catch (...) { \
-        RCUTILS_SAFE_FWRITE_TO_STDERR( \
-        "[rclcpp|logging.hpp] RCLCPP_@(severity)@(suffix) could not get current time stamp\n"); \
-        return RCUTILS_RET_ERROR; \
-      } \
-        return RCUTILS_RET_OK; \
-    }; \
-@[ end if] \
-@[ if 'stream' in feature_combination]@
-    std::stringstream rclcpp_stream_ss_; \
-    rclcpp_stream_ss_ << @(stream_arg); \
-@[ end if]@
-    RCUTILS_LOG_@(severity)@(get_suffix_from_features(feature_combination))_NAMED( \
-@{params = ['get_time_point' if p == 'clock' and 'throttle' in feature_combination else p for p in params]}@
-@[ if params]@
-@(''.join(['      ' + p + ', \\\n' for p in params if p != stream_arg]))@
-@[ end if]@
-      (logger).get_name(), \
-@[ if 'stream' not in feature_combination]@
-      __VA_ARGS__); \
-@[ else]@
-      "%s", rclcpp_stream_ss_.str().c_str()); \
-@[ end if]@
-  } while (0)
-
-@[ end for]@
-#endif
-///@@}
-
-@[end for]@
-
-#endif  // RCLCPP__LOGGING_HPP_

rclcpp/src/rclcpp/context.cpp

@@ -28,7 +28,7 @@
 #include "rclcpp/detail/utilities.hpp"
 #include "rclcpp/exceptions.hpp"
 #include "rclcpp/logging.hpp"
-
+#include "rclcpp/graph_listener.hpp"
 #include "rcutils/error_handling.h"
 #include "rcutils/macros.h"
 
@@ -145,7 +145,8 @@ rclcpp_logging_output_handler(
 Context::Context()
 : rcl_context_(nullptr),
   shutdown_reason_(""),
-  logging_mutex_(nullptr)
+  logging_mutex_(nullptr),
+  graph_listener_(nullptr)
 {}
 
 Context::~Context()
@@ -243,6 +244,24 @@ Context::init(
 
     weak_contexts_ = get_weak_contexts();
     weak_contexts_->add_context(this->shared_from_this());
+
+
+    std::lock_guard<std::recursive_mutex> lock (on_shutdown_callbacks_mutex_);
+
+    graph_listener_ = std::make_shared<graph_listener::GraphListener>(shared_from_this());
+
+    if (!graph_listener_->is_started()) {
+    // Register an on_shutdown hook to shutdown the graph listener.
+    // This is important to ensure that the wait set is finalized before
+    // destruction of static objects occurs.
+      std::weak_ptr<rclcpp::graph_listener::GraphListener> weak_graph_listener = graph_listener_;
+      on_shutdown ([weak_graph_listener]() {
+          auto shared_graph_listener = weak_graph_listener.lock();
+          if(shared_graph_listener) {
+            shared_graph_listener->shutdown(std::nothrow);
+          }
+    });
+    }
   } catch (const std::exception & e) {
     ret = rcl_shutdown(rcl_context_.get());
     rcl_context_.reset();
@@ -310,9 +329,16 @@ Context::shutdown(const std::string & reason)
 
   // call each pre-shutdown callback
   {
-    std::lock_guard<std::mutex> lock{pre_shutdown_callbacks_mutex_};
-    for (const auto & callback : pre_shutdown_callbacks_) {
-      (*callback)();
+    std::lock_guard<std::recursive_mutex> lock{pre_shutdown_callbacks_mutex_};
+    // callbacks may delete other callbacks during the execution,
+    // therefore we need to save a copy and check before execution
+    // if the next callback is still present
+    auto cpy = pre_shutdown_callbacks_;
+    for (const auto & callback : cpy) {
+      auto it = std::find(pre_shutdown_callbacks_.begin(), pre_shutdown_callbacks_.end(), callback);
+      if(it != pre_shutdown_callbacks_.end()) {
+        (*callback)();
+      }
     }
   }
 
@@ -325,9 +351,16 @@ Context::shutdown(const std::string & reason)
   shutdown_reason_ = reason;
   // call each shutdown callback
   {
-    std::lock_guard<std::mutex> lock(on_shutdown_callbacks_mutex_);
-    for (const auto & callback : on_shutdown_callbacks_) {
-      (*callback)();
+    std::lock_guard<std::recursive_mutex> lock(on_shutdown_callbacks_mutex_);
+    // callbacks may delete other callbacks during the execution,
+    // therefore we need to save a copy and check before execution
+    // if the next callback is still present
+    auto cpy = on_shutdown_callbacks_;
+    for (const auto & callback : cpy) {
+      auto it = std::find(on_shutdown_callbacks_.begin(), on_shutdown_callbacks_.end(), callback);
+      if(it != on_shutdown_callbacks_.end()) {
+        (*callback)();
+      }
     }
   }
 
@@ -398,10 +431,10 @@ Context::add_shutdown_callback(
     shutdown_type == ShutdownType::pre_shutdown || shutdown_type == ShutdownType::on_shutdown);
 
   if constexpr (shutdown_type == ShutdownType::pre_shutdown) {
-    std::lock_guard<std::mutex> lock(pre_shutdown_callbacks_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(pre_shutdown_callbacks_mutex_);
     pre_shutdown_callbacks_.emplace_back(callback_shared_ptr);
   } else {
-    std::lock_guard<std::mutex> lock(on_shutdown_callbacks_mutex_);
+    std::lock_guard<std::recursive_mutex> lock(on_shutdown_callbacks_mutex_);
     on_shutdown_callbacks_.emplace_back(callback_shared_ptr);
   }
 
@@ -421,7 +454,7 @@ Context::remove_shutdown_callback(
   }
 
   const auto remove_callback = [&callback_shared_ptr](auto & mutex, auto & callback_vector) {
-      const std::lock_guard<std::mutex> lock(mutex);
+      const std::lock_guard<std::recursive_mutex> lock(mutex);
       auto iter = callback_vector.begin();
       for (; iter != callback_vector.end(); iter++) {
         if ((*iter).get() == callback_shared_ptr.get()) {
@@ -462,7 +495,7 @@ std::vector<rclcpp::Context::ShutdownCallback>
 Context::get_shutdown_callback() const
 {
   const auto get_callback_vector = [](auto & mutex, auto & callback_set) {
-      const std::lock_guard<std::mutex> lock(mutex);
+      const std::lock_guard<std::recursive_mutex> lock(mutex);
       std::vector<rclcpp::Context::ShutdownCallback> callbacks;
       for (auto & callback : callback_set) {
         callbacks.push_back(*callback);
@@ -486,6 +519,12 @@ Context::get_rcl_context()
   return rcl_context_;
 }
 
+std::shared_ptr<rclcpp::graph_listener::GraphListener>
+Context::get_graph_listener()
+{
+  return graph_listener_;
+}
+
 bool
 Context::sleep_for(const std::chrono::nanoseconds & nanoseconds)
 {

rclcpp/src/rclcpp/executor.cpp

@@ -18,6 +18,7 @@
 #include <iterator>
 #include <memory>
 #include <map>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -52,6 +53,7 @@ class rclcpp::ExecutorImplementation {};
 
 Executor::Executor(const std::shared_ptr<rclcpp::Context> & context)
 : spinning(false),
+  context_(context),
   entities_need_rebuild_(true),
   collector_(nullptr),
   wait_set_({}, {}, {}, {}, {}, {}, context)
@@ -186,6 +188,11 @@ Executor::add_callback_group(
 void
 Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
 {
+  if (node_ptr->get_context() != context_) {
+    throw std::runtime_error(
+      "add_node() called with a node with a different context from this executor");
+  }
+
   this->collector_.add_node(node_ptr);
 
   try {

rclcpp/src/rclcpp/executors.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "rclcpp/executors.hpp"
+#include "rcpputils/compile_warnings.hpp"
 
 void
 rclcpp::spin_all(
@@ -25,12 +26,6 @@ rclcpp::spin_all(
   exec.spin_node_all(node_ptr, max_duration);
 }
 
-void
-rclcpp::spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration)
-{
-  rclcpp::spin_all(node_ptr->get_node_base_interface(), max_duration);
-}
-
 void
 rclcpp::spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
@@ -40,12 +35,6 @@ rclcpp::spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr
   exec.spin_node_some(node_ptr);
 }
 
-void
-rclcpp::spin_some(rclcpp::Node::SharedPtr node_ptr)
-{
-  rclcpp::spin_some(node_ptr->get_node_base_interface());
-}
-
 void
 rclcpp::spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
@@ -62,3 +51,19 @@ rclcpp::spin(rclcpp::Node::SharedPtr node_ptr)
 {
   rclcpp::spin(node_ptr->get_node_base_interface());
 }
+
+void
+rclcpp::spin_all(rclcpp::Node::SharedPtr node_ptr, std::chrono::nanoseconds max_duration)
+{
+  RCPPUTILS_DEPRECATION_WARNING_OFF_START
+  rclcpp::spin_all(node_ptr->get_node_base_interface(), max_duration);
+  RCPPUTILS_DEPRECATION_WARNING_OFF_STOP
+}
+
+void
+rclcpp::spin_some(rclcpp::Node::SharedPtr node_ptr)
+{
+  RCPPUTILS_DEPRECATION_WARNING_OFF_START
+  rclcpp::spin_some(node_ptr->get_node_base_interface());
+  RCPPUTILS_DEPRECATION_WARNING_OFF_STOP
+}

rclcpp/src/rclcpp/executors/static_single_threaded_executor.cpp

@@ -1,223 +0,0 @@
-// Copyright 2019 Nobleo Technology
-//
-// 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 "rclcpp/executors/executor_entities_collection.hpp"
-#include "rcpputils/scope_exit.hpp"
-
-#include "rclcpp/executors/static_single_threaded_executor.hpp"
-#include "rclcpp/any_executable.hpp"
-
-using rclcpp::executors::StaticSingleThreadedExecutor;
-
-StaticSingleThreadedExecutor::StaticSingleThreadedExecutor(const rclcpp::ExecutorOptions & options)
-: rclcpp::Executor(options)
-{
-}
-
-StaticSingleThreadedExecutor::~StaticSingleThreadedExecutor() {}
-
-void
-StaticSingleThreadedExecutor::spin()
-{
-  if (spinning.exchange(true)) {
-    throw std::runtime_error("spin() called while already spinning");
-  }
-  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false); );
-
-  // This is essentially the contents of the rclcpp::Executor::wait_for_work method,
-  // except we need to keep the wait result to reproduce the StaticSingleThreadedExecutor
-  // behavior.
-  while (rclcpp::ok(this->context_) && spinning.load()) {
-    this->spin_once_impl(std::chrono::nanoseconds(-1));
-  }
-}
-
-void
-StaticSingleThreadedExecutor::spin_some(std::chrono::nanoseconds max_duration)
-{
-  // In this context a 0 input max_duration means no duration limit
-  if (std::chrono::nanoseconds(0) == max_duration) {
-    max_duration = std::chrono::nanoseconds::max();
-  }
-  return this->spin_some_impl(max_duration, false);
-}
-
-void
-StaticSingleThreadedExecutor::spin_all(std::chrono::nanoseconds max_duration)
-{
-  if (max_duration < std::chrono::nanoseconds(0)) {
-    throw std::invalid_argument("max_duration must be greater than or equal to 0");
-  }
-  return this->spin_some_impl(max_duration, true);
-}
-
-void
-StaticSingleThreadedExecutor::spin_some_impl(std::chrono::nanoseconds max_duration, bool exhaustive)
-{
-  auto start = std::chrono::steady_clock::now();
-  auto max_duration_not_elapsed = [max_duration, start]() {
-      const auto spin_forever = std::chrono::nanoseconds(0) == max_duration;
-      const auto cur_duration = std::chrono::steady_clock::now() - start;
-      return spin_forever || (cur_duration < max_duration);
-    };
-
-  if (spinning.exchange(true)) {
-    throw std::runtime_error("spin_some() called while already spinning");
-  }
-  RCPPUTILS_SCOPE_EXIT(this->spinning.store(false););
-
-  while (rclcpp::ok(context_) && spinning.load() && max_duration_not_elapsed()) {
-    // Get executables that are ready now
-    std::lock_guard<std::mutex> guard(mutex_);
-
-    auto wait_result = this->collect_and_wait(std::chrono::nanoseconds(0));
-    if (wait_result.has_value()) {
-      // Execute ready executables
-      bool work_available = this->execute_ready_executables(
-        current_collection_,
-        wait_result.value(),
-        false);
-      if (!work_available || !exhaustive) {
-        break;
-      }
-    }
-  }
-}
-
-void
-StaticSingleThreadedExecutor::spin_once_impl(std::chrono::nanoseconds timeout)
-{
-  if (rclcpp::ok(context_) && spinning.load()) {
-    std::lock_guard<std::mutex> guard(mutex_);
-    auto wait_result = this->collect_and_wait(timeout);
-    if (wait_result.has_value()) {
-      this->execute_ready_executables(current_collection_, wait_result.value(), true);
-    }
-  }
-}
-
-std::optional<rclcpp::WaitResult<rclcpp::WaitSet>>
-StaticSingleThreadedExecutor::collect_and_wait(std::chrono::nanoseconds timeout)
-{
-  // we need to make sure that callback groups don't get out of scope
-  // during the wait. As in jazzy, they are not covered by the DynamicStorage,
-  // we explicitly hold them here as a bugfix
-  std::vector<rclcpp::CallbackGroup::SharedPtr> cbgs;
-
-  if (this->entities_need_rebuild_.exchange(false) || current_collection_.empty()) {
-    this->collect_entities();
-  }
-
-  auto callback_groups = this->collector_.get_all_callback_groups();
-  cbgs.resize(callback_groups.size());
-  for(const auto & w_ptr : callback_groups) {
-    auto shr_ptr = w_ptr.lock();
-    if(shr_ptr) {
-      cbgs.push_back(std::move(shr_ptr));
-    }
-  }
-
-  auto wait_result = wait_set_.wait(std::chrono::nanoseconds(timeout));
-
-  // drop references to the callback groups, before trying to execute anything
-  cbgs.clear();
-
-  if (wait_result.kind() == WaitResultKind::Empty) {
-    RCUTILS_LOG_WARN_NAMED(
-      "rclcpp",
-      "empty wait set received in wait(). This should never happen.");
-    return {};
-  } else {
-    if (wait_result.kind() == WaitResultKind::Ready && current_notify_waitable_) {
-      auto & rcl_wait_set = wait_result.get_wait_set().get_rcl_wait_set();
-      if (current_notify_waitable_->is_ready(rcl_wait_set)) {
-        current_notify_waitable_->execute(current_notify_waitable_->take_data());
-      }
-    }
-  }
-  return wait_result;
-}
-
-// This preserves the "scheduling semantics" of the StaticSingleThreadedExecutor
-// from the original implementation.
-bool StaticSingleThreadedExecutor::execute_ready_executables(
-  const rclcpp::executors::ExecutorEntitiesCollection & collection,
-  rclcpp::WaitResult<rclcpp::WaitSet> & wait_result,
-  bool spin_once)
-{
-  bool any_ready_executable = false;
-  if (wait_result.kind() != rclcpp::WaitResultKind::Ready) {
-    return any_ready_executable;
-  }
-
-  while (auto subscription = wait_result.next_ready_subscription()) {
-    auto entity_iter = collection.subscriptions.find(subscription->get_subscription_handle().get());
-    if (entity_iter != collection.subscriptions.end()) {
-      execute_subscription(subscription);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  size_t current_timer_index = 0;
-  while (true) {
-    auto [timer, timer_index] = wait_result.peek_next_ready_timer(current_timer_index);
-    if (nullptr == timer) {
-      break;
-    }
-    current_timer_index = timer_index;
-    auto entity_iter = collection.timers.find(timer->get_timer_handle().get());
-    if (entity_iter != collection.timers.end()) {
-      wait_result.clear_timer_with_index(current_timer_index);
-      auto data = timer->call();
-      if (!data) {
-        // someone canceled the timer between is_ready and call
-        continue;
-      }
-
-      execute_timer(std::move(timer), data);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  while (auto client = wait_result.next_ready_client()) {
-    auto entity_iter = collection.clients.find(client->get_client_handle().get());
-    if (entity_iter != collection.clients.end()) {
-      execute_client(client);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  while (auto service = wait_result.next_ready_service()) {
-    auto entity_iter = collection.services.find(service->get_service_handle().get());
-    if (entity_iter != collection.services.end()) {
-      execute_service(service);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-
-  while (auto waitable = wait_result.next_ready_waitable()) {
-    auto entity_iter = collection.waitables.find(waitable.get());
-    if (entity_iter != collection.waitables.end()) {
-      const auto data = waitable->take_data();
-      waitable->execute(data);
-      any_ready_executable = true;
-      if (spin_once) {return any_ready_executable;}
-    }
-  }
-  return any_ready_executable;
-}

rclcpp/src/rclcpp/experimental/executors/events_executor/events_executor.cpp

@@ -25,9 +25,9 @@ using namespace std::chrono_literals;
 using rclcpp::experimental::executors::EventsExecutor;
 
 EventsExecutor::EventsExecutor(
+  const rclcpp::ExecutorOptions & options,
   rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue,
-  bool execute_timers_separate_thread,
-  const rclcpp::ExecutorOptions & options)
+  bool execute_timers_separate_thread)
 : rclcpp::Executor(options)
 {
   // Get ownership of the queue used to store events.

rclcpp/src/rclcpp/graph_listener.cpp

@@ -19,7 +19,6 @@
 #include <memory>
 #include <string>
 #include <vector>
-
 #include "rcl/error_handling.h"
 #include "rcl/types.h"
 #include "rclcpp/detail/add_guard_condition_to_rcl_wait_set.hpp"
@@ -38,8 +37,7 @@ namespace graph_listener
 {
 
 GraphListener::GraphListener(const std::shared_ptr<Context> & parent_context)
-: weak_parent_context_(parent_context),
-  rcl_parent_context_(parent_context->get_rcl_context()),
+: rcl_parent_context_(parent_context->get_rcl_context()),
   is_started_(false),
   is_shutdown_(false),
   interrupt_guard_condition_(parent_context)
@@ -72,23 +70,11 @@ void
 GraphListener::start_if_not_started()
 {
   std::lock_guard<std::mutex> shutdown_lock(shutdown_mutex_);
-  if (is_shutdown_.load()) {
+  if (is_shutdown()) {
     throw GraphListenerShutdownError();
   }
-  auto parent_context = weak_parent_context_.lock();
-  if (!is_started_ && parent_context) {
-    // Register an on_shutdown hook to shtudown the graph listener.
-    // This is important to ensure that the wait set is finalized before
-    // destruction of static objects occurs.
-    std::weak_ptr<GraphListener> weak_this = shared_from_this();
-    parent_context->on_shutdown(
-      [weak_this]() {
-        auto shared_this = weak_this.lock();
-        if (shared_this) {
-          // should not throw from on_shutdown if it can be avoided
-          shared_this->shutdown(std::nothrow);
-        }
-      });
+
+  if (!is_started()) {
     // Initialize the wait set before starting.
     init_wait_set();
     // Start the listener thread.
@@ -122,7 +108,7 @@ GraphListener::run_loop()
 {
   while (true) {
     // If shutdown() was called, exit.
-    if (is_shutdown_.load()) {
+    if (is_shutdown()) {
       return;
     }
     rcl_ret_t ret;
@@ -190,7 +176,7 @@ GraphListener::run_loop()
       if (graph_gc == wait_set_.guard_conditions[graph_gc_indexes[i]]) {
         node_ptr->notify_graph_change();
       }
-      if (is_shutdown_) {
+      if (is_shutdown()) {
         // If shutdown, then notify the node of this as well.
         node_ptr->notify_shutdown();
       }
@@ -257,7 +243,7 @@ GraphListener::add_node(rclcpp::node_interfaces::NodeGraphInterface * node_graph
     throw std::invalid_argument("node is nullptr");
   }
   std::lock_guard<std::mutex> shutdown_lock(shutdown_mutex_);
-  if (is_shutdown_.load()) {
+  if (is_shutdown()) {
     throw GraphListenerShutdownError();
   }
 
@@ -332,11 +318,11 @@ GraphListener::__shutdown()
 {
   std::lock_guard<std::mutex> shutdown_lock(shutdown_mutex_);
   if (!is_shutdown_.exchange(true)) {
-    if (is_started_) {
+    if (is_started()) {
       interrupt_(&interrupt_guard_condition_);
       listener_thread_.join();
     }
-    if (is_started_) {
+    if (is_started()) {
       cleanup_wait_set();
     }
   }
@@ -365,6 +351,12 @@ GraphListener::shutdown(const std::nothrow_t &) noexcept
   }
 }
 
+bool
+GraphListener::is_started()
+{
+  return is_started_;
+}
+
 bool
 GraphListener::is_shutdown()
 {

rclcpp/src/rclcpp/node_interfaces/node_base.cpp

@@ -275,16 +275,6 @@ NodeBase::get_associated_with_executor_atomic()
   return associated_with_executor_;
 }
 
-rclcpp::GuardCondition &
-NodeBase::get_notify_guard_condition()
-{
-  std::lock_guard<std::recursive_mutex> notify_condition_lock(notify_guard_condition_mutex_);
-  if (!notify_guard_condition_is_valid_) {
-    throw std::runtime_error("failed to get notify guard condition because it is invalid");
-  }
-  return *notify_guard_condition_;
-}
-
 rclcpp::GuardCondition::SharedPtr
 NodeBase::get_shared_notify_guard_condition()
 {

rclcpp/src/rclcpp/node_interfaces/node_graph.cpp

@@ -36,9 +36,6 @@ using rclcpp::graph_listener::GraphListener;
 
 NodeGraph::NodeGraph(rclcpp::node_interfaces::NodeBaseInterface * node_base)
 : node_base_(node_base),
-  graph_listener_(
-    node_base->get_context()->get_sub_context<GraphListener>(node_base->get_context())
-  ),
   should_add_to_graph_listener_(true),
   graph_users_count_(0)
 {}
@@ -50,7 +47,7 @@ NodeGraph::~NodeGraph()
   // graph listener after checking that it was not here.
   if (!should_add_to_graph_listener_.exchange(false)) {
     // If it was already false, then it needs to now be removed.
-    graph_listener_->remove_node(this);
+    node_base_->get_context()->get_graph_listener()->remove_node(this);
   }
 }
 
@@ -419,7 +416,7 @@ NodeGraph::get_node_names_and_namespaces() const
         rcl_get_error_string().str;
       rcl_reset_error();
     }
-    // TODO(karsten1987): Append rcutils_error_message once it's in master
+    RCUTILS_LOG_ERROR_NAMED("rclcpp", "%s", error_msg.c_str());
     throw std::runtime_error(error_msg);
   }
 
@@ -434,20 +431,15 @@ NodeGraph::get_node_names_and_namespaces() const
   std::string error;
   rcl_ret_t ret_names = rcutils_string_array_fini(&node_names_c);
   if (ret_names != RCUTILS_RET_OK) {
-    // *INDENT-OFF*
-    // TODO(karsten1987): Append rcutils_error_message once it's in master
-    error = "could not destroy node names";
-    // *INDENT-ON*
+    error = std::string("could not destroy node names: ") + rcl_get_error_string().str;
   }
   rcl_ret_t ret_ns = rcutils_string_array_fini(&node_namespaces_c);
   if (ret_ns != RCUTILS_RET_OK) {
-    // *INDENT-OFF*
-    // TODO(karsten1987): Append rcutils_error_message once it's in master
-    error += ", could not destroy node namespaces";
-    // *INDENT-ON*
+    error += std::string(", could not destroy node namespaces: ") + rcl_get_error_string().str;
   }
 
   if (ret_names != RCUTILS_RET_OK || ret_ns != RCUTILS_RET_OK) {
+    RCUTILS_LOG_ERROR_NAMED("rclcpp", "%s", error.c_str());
     throw std::runtime_error(error);
   }
 
@@ -603,8 +595,8 @@ NodeGraph::get_graph_event()
   }
   // on first call, add node to graph_listener_
   if (should_add_to_graph_listener_.exchange(false)) {
-    graph_listener_->add_node(this);
-    graph_listener_->start_if_not_started();
+    node_base_->get_context()->get_graph_listener()->add_node(this);
+    node_base_->get_context()->get_graph_listener()->start_if_not_started();
   }
   return event;
 }

rclcpp/src/rclcpp/node_interfaces/node_type_descriptions.cpp

@@ -65,11 +65,11 @@ public:
   : logger_(node_logging->get_logger()),
     node_base_(node_base)
   {
+    rclcpp::ParameterValue enable_param;
     const std::string enable_param_name = "start_type_description_service";
 
-    bool enabled = false;
-    try {
-      auto enable_param = node_parameters->declare_parameter(
+    if (!node_parameters->has_parameter(enable_param_name)) {
+      enable_param = node_parameters->declare_parameter(
         enable_param_name,
         rclcpp::ParameterValue(true),
         rcl_interfaces::msg::ParameterDescriptor()
@@ -77,13 +77,21 @@ public:
         .set__type(rclcpp::PARAMETER_BOOL)
         .set__description("Start the ~/get_type_description service for this node.")
         .set__read_only(true));
-      enabled = enable_param.get<bool>();
-    } catch (const rclcpp::exceptions::InvalidParameterTypeException & exc) {
-      RCLCPP_ERROR(logger_, "%s", exc.what());
-      throw;
+    } else {
+      enable_param = node_parameters->get_parameter(enable_param_name).get_parameter_value();
+    }
+    if (enable_param.get_type() != rclcpp::PARAMETER_BOOL) {
+      RCLCPP_ERROR(
+        logger_,
+            "Invalid type '%s' for parameter 'start_type_description_service', should be 'bool'",
+        rclcpp::to_string(enable_param.get_type()).c_str());
+      std::ostringstream ss;
+      ss << "Wrong parameter type, parameter {" << enable_param_name << "} is of type {bool}, "
+         << "setting it to {" << to_string(enable_param.get_type()) << "} is not allowed.";
+      throw rclcpp::exceptions::InvalidParameterTypeException(enable_param_name, ss.str());
     }
 
-    if (enabled) {
+    if (enable_param.get<bool>()) {
       auto * rcl_node = node_base->get_rcl_node_handle();
       std::shared_ptr<rcl_service_t> rcl_srv(
         new rcl_service_t,

rclcpp/src/rclcpp/parameter_map.cpp

@@ -81,7 +81,15 @@ rclcpp::parameter_map_from(const rcl_params_t * const c_params, const char * nod
         throw InvalidParametersException(message);
       }
       const rcl_variant_t * const c_param_value = &(c_params_node->parameter_values[p]);
-      params_node.emplace_back(c_param_name, parameter_value_from(c_param_value));
+      ParameterValue value;
+      try {
+        value = parameter_value_from(c_param_value);
+      } catch (const InvalidParameterValueException & e) {
+        throw InvalidParameterValueException(
+          std::string("parameter_value_from failed for parameter '") +
+          c_param_name + "': " + e.what());
+      }
+      params_node.emplace_back(c_param_name, value);
     }
   }
 

rclcpp/src/rclcpp/qos.cpp

@@ -69,8 +69,10 @@ QoSInitialization::from_rmw(const rmw_qos_profile_t & rmw_qos)
       return KeepLast(rmw_qos.depth, false);
     case RMW_QOS_POLICY_HISTORY_KEEP_LAST:
     case RMW_QOS_POLICY_HISTORY_UNKNOWN:
-    default:
       return KeepLast(rmw_qos.depth);
+    default:
+      throw std::invalid_argument(
+        "Invalid history policy enum value passed to QoSInitialization::from_rmw");
   }
 }
 

rclcpp/src/rclcpp/rate.cpp

@@ -67,7 +67,13 @@ Rate::sleep()
   // Calculate the time to sleep
   auto time_to_sleep = next_interval - now;
   // Sleep (will get interrupted by ctrl-c, may not sleep full time)
-  clock_->sleep_for(time_to_sleep);
+  try {
+    // If the context is invalid, an exception will be thrown.
+    clock_->sleep_for(time_to_sleep);
+  } catch (const std::runtime_error & e) {
+    // If it didn't sleep the full time, return false
+    return false;
+  }
   return true;
 }
 

rclcpp/src/rclcpp/serialized_message.cpp

@@ -26,8 +26,13 @@ namespace rclcpp
 
 inline void copy_rcl_message(const rcl_serialized_message_t & from, rcl_serialized_message_t & to)
 {
-  const auto ret = rmw_serialized_message_init(
-    &to, from.buffer_capacity, &from.allocator);
+  auto ret = RCL_RET_ERROR;
+  if (nullptr == to.buffer) {
+    ret = rmw_serialized_message_init(&to, from.buffer_capacity, &from.allocator);
+  } else {
+    ret = rmw_serialized_message_resize(&to, from.buffer_capacity);
+  }
+
   if (RCL_RET_OK != ret) {
     rclcpp::exceptions::throw_from_rcl_error(ret);
   }
@@ -78,7 +83,6 @@ SerializedMessage::SerializedMessage(rcl_serialized_message_t && other)
 SerializedMessage & SerializedMessage::operator=(const SerializedMessage & other)
 {
   if (this != &other) {
-    serialized_message_ = rmw_get_zero_initialized_serialized_message();
     copy_rcl_message(other.serialized_message_, serialized_message_);
   }
 
@@ -88,7 +92,6 @@ SerializedMessage & SerializedMessage::operator=(const SerializedMessage & other
 SerializedMessage & SerializedMessage::operator=(const rcl_serialized_message_t & other)
 {
   if (&serialized_message_ != &other) {
-    serialized_message_ = rmw_get_zero_initialized_serialized_message();
     copy_rcl_message(other, serialized_message_);
   }
 
@@ -98,6 +101,14 @@ SerializedMessage & SerializedMessage::operator=(const rcl_serialized_message_t
 SerializedMessage & SerializedMessage::operator=(SerializedMessage && other)
 {
   if (this != &other) {
+    if (nullptr != serialized_message_.buffer) {
+      const auto fini_ret = rmw_serialized_message_fini(&serialized_message_);
+      if (RCL_RET_OK != fini_ret) {
+        RCLCPP_ERROR(
+          get_logger("rclcpp"),
+          "Failed to destroy serialized message: %s", rcl_get_error_string().str);
+      }
+    }
     serialized_message_ =
       std::exchange(other.serialized_message_, rmw_get_zero_initialized_serialized_message());
   }
@@ -108,6 +119,14 @@ SerializedMessage & SerializedMessage::operator=(SerializedMessage && other)
 SerializedMessage & SerializedMessage::operator=(rcl_serialized_message_t && other)
 {
   if (&serialized_message_ != &other) {
+    if (nullptr != serialized_message_.buffer) {
+      const auto fini_ret = rmw_serialized_message_fini(&serialized_message_);
+      if (RCL_RET_OK != fini_ret) {
+        RCLCPP_ERROR(
+          get_logger("rclcpp"),
+          "Failed to destroy serialized message: %s", rcl_get_error_string().str);
+      }
+    }
     serialized_message_ =
       std::exchange(other, rmw_get_zero_initialized_serialized_message());
   }

rclcpp/src/rclcpp/typesupport_helpers.cpp

@@ -15,6 +15,7 @@
 
 #include "rclcpp/typesupport_helpers.hpp"
 
+#include <algorithm>
 #include <functional>
 #include <memory>
 #include <sstream>
@@ -35,62 +36,6 @@ namespace rclcpp
 namespace
 {
 
-// Look for the library in the ament prefix paths.
-std::string get_typesupport_library_path(
-  const std::string & package_name, const std::string & typesupport_identifier)
-{
-  const char * dynamic_library_folder;
-#ifdef _WIN32
-  dynamic_library_folder = "/bin/";
-#elif __APPLE__
-  dynamic_library_folder = "/lib/";
-#else
-  dynamic_library_folder = "/lib/";
-#endif
-
-  std::string package_prefix;
-  try {
-    package_prefix = ament_index_cpp::get_package_prefix(package_name);
-  } catch (ament_index_cpp::PackageNotFoundError & e) {
-    throw std::runtime_error(e.what());
-  }
-
-  const std::string library_path = rcpputils::path_for_library(
-    package_prefix + dynamic_library_folder,
-    package_name + "__" + typesupport_identifier);
-  if (library_path.empty()) {
-    throw std::runtime_error(
-            "Typesupport library for " + package_name + " does not exist in '" + package_prefix +
-            "'.");
-  }
-  return library_path;
-}
-
-std::tuple<std::string, std::string, std::string>
-extract_type_identifier(const std::string & full_type)
-{
-  char type_separator = '/';
-  auto sep_position_back = full_type.find_last_of(type_separator);
-  auto sep_position_front = full_type.find_first_of(type_separator);
-  if (sep_position_back == std::string::npos ||
-    sep_position_back == 0 ||
-    sep_position_back == full_type.length() - 1)
-  {
-    throw std::runtime_error(
-            "Message type is not of the form package/type and cannot be processed");
-  }
-
-  std::string package_name = full_type.substr(0, sep_position_front);
-  std::string middle_module = "";
-  if (sep_position_back - sep_position_front > 0) {
-    middle_module =
-      full_type.substr(sep_position_front + 1, sep_position_back - sep_position_front - 1);
-  }
-  std::string type_name = full_type.substr(sep_position_back + 1);
-
-  return std::make_tuple(package_name, middle_module, type_name);
-}
-
 const void * get_typesupport_handle_impl(
   const std::string & type,
   const std::string & typesupport_identifier,
@@ -129,8 +74,80 @@ const void * get_typesupport_handle_impl(
   }
 }
 
+// Trim leading and trailing whitespace from the string.
+std::string string_trim(std::string_view str_v)
+{
+  auto begin = std::find_if_not(str_v.begin(), str_v.end(), [](unsigned char ch) {
+        return std::isspace(ch);
+  });
+  auto end = std::find_if_not(str_v.rbegin(), str_v.rend(), [](unsigned char ch) {
+        return std::isspace(ch);
+  }).base();
+  if (begin >= end) {
+    return {};
+  }
+  return std::string(begin, end);
+}
+
 }  // anonymous namespace
 
+std::tuple<std::string, std::string, std::string>
+extract_type_identifier(const std::string & full_type)
+{
+  char type_separator = '/';
+  auto sep_position_back = full_type.find_last_of(type_separator);
+  auto sep_position_front = full_type.find_first_of(type_separator);
+  if (sep_position_back == std::string::npos ||
+    sep_position_front == 0 ||
+    sep_position_back == 0 ||
+    sep_position_back == full_type.length() - 1)
+  {
+    throw std::runtime_error(
+      "Message type is not of the form package/type and cannot be processed");
+  }
+
+  std::string package_name = full_type.substr(0, sep_position_front);
+  std::string middle_module = "";
+  if (sep_position_back - sep_position_front > 0) {
+    middle_module =
+      full_type.substr(sep_position_front + 1, sep_position_back - sep_position_front - 1);
+  }
+  std::string type_name = full_type.substr(sep_position_back + 1);
+
+  return std::make_tuple(
+    string_trim(package_name), string_trim(middle_module), string_trim(type_name));
+}
+
+std::string get_typesupport_library_path(
+  const std::string & package_name, const std::string & typesupport_identifier)
+{
+  const char * dynamic_library_folder;
+#ifdef _WIN32
+  dynamic_library_folder = "/bin/";
+#elif __APPLE__
+  dynamic_library_folder = "/lib/";
+#else
+  dynamic_library_folder = "/lib/";
+#endif
+
+  std::string package_prefix;
+  try {
+    package_prefix = ament_index_cpp::get_package_prefix(package_name);
+  } catch (ament_index_cpp::PackageNotFoundError & e) {
+    throw std::runtime_error(e.what());
+  }
+
+  const std::string library_path = rcpputils::path_for_library(
+    package_prefix + dynamic_library_folder,
+    package_name + "__" + typesupport_identifier);
+  if (library_path.empty()) {
+    throw std::runtime_error(
+      "Typesupport library for " + package_name + " does not exist in '" + package_prefix +
+        "'.");
+  }
+  return library_path;
+}
+
 std::shared_ptr<rcpputils::SharedLibrary>
 get_typesupport_library(const std::string & type, const std::string & typesupport_identifier)
 {

rclcpp/test/benchmark/benchmark_executor.cpp

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <chrono>
 #include <memory>
 #include <string>
 #include <utility>

rclcpp/test/benchmark/benchmark_service.cpp

@@ -125,11 +125,13 @@ BENCHMARK_F(ServicePerformanceTest, async_send_response)(benchmark::State & stat
   auto service = node->create_service<test_msgs::srv::Empty>(empty_service_name, callback);
 
   reset_heap_counters();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node->get_node_base_interface());
   for (auto _ : state) {
     (void)_;
     state.PauseTiming();
     // Clear executor queue
-    rclcpp::spin_some(node->get_node_base_interface());
+    executor.spin_some();
 
     auto request = std::make_shared<test_msgs::srv::Empty::Request>();
     auto future = empty_client->async_send_request(request);
@@ -137,7 +139,7 @@ BENCHMARK_F(ServicePerformanceTest, async_send_response)(benchmark::State & stat
     benchmark::DoNotOptimize(service);
     benchmark::ClobberMemory();
 
-    rclcpp::spin_until_future_complete(node->get_node_base_interface(), future);
+    executor.spin_until_future_complete(future);
   }
   if (callback_count == 0) {
     state.SkipWithError("Service callback was not called");

rclcpp/test/rclcpp/CMakeLists.txt

@@ -529,13 +529,6 @@ if(TARGET test_executors_warmup)
   target_link_libraries(test_executors_warmup ${PROJECT_NAME} ${test_msgs_TARGETS})
 endif()
 
-ament_add_gtest(test_static_single_threaded_executor executors/test_static_single_threaded_executor.cpp
-  APPEND_LIBRARY_DIRS "${append_library_dirs}")
-ament_add_test_label(test_static_single_threaded_executor mimick)
-if(TARGET test_static_single_threaded_executor)
-  target_link_libraries(test_static_single_threaded_executor ${PROJECT_NAME} mimick ${test_msgs_TARGETS})
-endif()
-
 ament_add_gtest(test_multi_threaded_executor executors/test_multi_threaded_executor.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_multi_threaded_executor)

rclcpp/test/rclcpp/executors/executor_types.hpp

@@ -22,40 +22,13 @@
 
 #include "rclcpp/experimental/executors/events_executor/events_executor.hpp"
 #include "rclcpp/executors/single_threaded_executor.hpp"
-#include "rclcpp/executors/static_single_threaded_executor.hpp"
 #include "rclcpp/executors/multi_threaded_executor.hpp"
 
-// suppress deprecated StaticSingleThreadedExecutor warning
-// we define an alias that explicitly indicates that this class is deprecated, while avoiding
-// polluting a lot of files the gcc pragmas
-#if !defined(_WIN32)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#else  // !defined(_WIN32)
-# pragma warning(push)
-# pragma warning(disable: 4996)
-#endif
-using DeprecatedStaticSingleThreadedExecutor = rclcpp::executors::StaticSingleThreadedExecutor;
-// remove warning suppression
-#if !defined(_WIN32)
-# pragma GCC diagnostic pop
-#else  // !defined(_WIN32)
-# pragma warning(pop)
-#endif
-
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
 using ExecutorTypes =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,
   rclcpp::executors::MultiThreadedExecutor,
-  DeprecatedStaticSingleThreadedExecutor,
   rclcpp::experimental::executors::EventsExecutor>;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
 
 class ExecutorTypeNames
 {
@@ -70,16 +43,6 @@ public:
     if (std::is_same<T, rclcpp::executors::MultiThreadedExecutor>()) {
       return "MultiThreadedExecutor";
     }
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-    if (std::is_same<T, DeprecatedStaticSingleThreadedExecutor>()) {
-      return "StaticSingleThreadedExecutor";
-    }
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
 
     if (std::is_same<T, rclcpp::experimental::executors::EventsExecutor>()) {
       return "EventsExecutor";
@@ -89,8 +52,6 @@ public:
   }
 };
 
-// StaticSingleThreadedExecutor is not included in these tests for now, due to:
-// https://github.com/ros2/rclcpp/issues/1219
 using StandardExecutors =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,

rclcpp/test/rclcpp/executors/test_events_queue.cpp

@@ -14,6 +14,7 @@
 
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include <memory>
 
 #include "rclcpp/experimental/executors/events_executor/events_executor_event_types.hpp"

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -804,8 +804,10 @@ TEST(TestExecutors, testSpinUntilFutureCompleteNodePtr)
 }
 
 // Check spin functions with non default context
-TEST(TestExecutors, testSpinWithNonDefaultContext)
+TYPED_TEST(TestExecutors, testSpinWithNonDefaultContext)
 {
+  using ExecutorType = TypeParam;
+
   auto non_default_context = std::make_shared<rclcpp::Context>();
   non_default_context->init(0, nullptr);
 
@@ -813,9 +815,14 @@ TEST(TestExecutors, testSpinWithNonDefaultContext)
     auto node =
       std::make_unique<rclcpp::Node>("node", rclcpp::NodeOptions().context(non_default_context));
 
-    EXPECT_NO_THROW(rclcpp::spin_some(node->get_node_base_interface()));
+    rclcpp::ExecutorOptions options;
+    options.context = non_default_context;
+    ExecutorType executor(options);
+    EXPECT_NO_THROW(executor.add_node(node->get_node_base_interface()));
 
-    EXPECT_NO_THROW(rclcpp::spin_all(node->get_node_base_interface(), 1s));
+    EXPECT_NO_THROW(executor.spin_some());
+
+    EXPECT_NO_THROW(executor.spin_all(1s));
 
     auto check_spin_until_future_complete = [&]() {
         std::promise<bool> promise;
@@ -823,8 +830,7 @@ TEST(TestExecutors, testSpinWithNonDefaultContext)
         promise.set_value(true);
 
         auto shared_future = future.share();
-        auto ret = rclcpp::spin_until_future_complete(
-          node->get_node_base_interface(), shared_future, 1s);
+        auto ret = executor.spin_until_future_complete(shared_future, 1s);
         EXPECT_EQ(rclcpp::FutureReturnCode::SUCCESS, ret);
       };
     EXPECT_NO_THROW(check_spin_until_future_complete());

rclcpp/test/rclcpp/executors/test_executors_timer_cancel_behavior.cpp

@@ -285,20 +285,11 @@ public:
   T executor;
 };
 
-#if !defined(_WIN32)
-# ifdef __clang__
-#  pragma clang diagnostic push
-#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
-# endif
-#endif
 using MainExecutorTypes =
   ::testing::Types<
   rclcpp::executors::SingleThreadedExecutor,
-  rclcpp::executors::MultiThreadedExecutor,
-  DeprecatedStaticSingleThreadedExecutor>;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
+  rclcpp::executors::MultiThreadedExecutor>;
+
 // TODO(@fujitatomoya): this test excludes EventExecutor because it does not
 // support simulation time used for this test to relax the racy condition.
 // See more details for https://github.com/ros2/rclcpp/issues/2457.

rclcpp/test/rclcpp/executors/test_static_single_threaded_executor.cpp

@@ -1,192 +0,0 @@
-// Copyright 2020 Open Source Robotics Foundation, Inc.
-//
-// 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 <gtest/gtest.h>
-
-#include <chrono>
-#include <future>
-#include <memory>
-#include <stdexcept>
-
-#include "rclcpp/exceptions.hpp"
-#include "rclcpp/executors.hpp"
-#include "rclcpp/node.hpp"
-#include "rclcpp/rclcpp.hpp"
-
-#include "test_msgs/srv/empty.hpp"
-
-#include "./executor_types.hpp"
-#include "../../mocking_utils/patch.hpp"
-#include "../../utils/rclcpp_gtest_macros.hpp"
-
-using namespace std::chrono_literals;
-
-class TestStaticSingleThreadedExecutor : public ::testing::Test
-{
-public:
-  void SetUp()
-  {
-    rclcpp::init(0, nullptr);
-  }
-
-  void TearDown()
-  {
-    rclcpp::shutdown();
-  }
-};
-
-TEST_F(TestStaticSingleThreadedExecutor, add_callback_group_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-  rclcpp::CallbackGroup::SharedPtr cb_group = node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive);
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.add_callback_group(cb_group, node->get_node_base_interface(), true),
-      std::runtime_error("Failed to handle entities update on callback group add: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, add_node_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.add_node(node),
-      std::runtime_error("Failed to handle entities update on node add: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, remove_callback_group_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-  rclcpp::CallbackGroup::SharedPtr cb_group = node->create_callback_group(
-    rclcpp::CallbackGroupType::MutuallyExclusive);
-
-  executor.add_callback_group(cb_group, node->get_node_base_interface(), true);
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.remove_callback_group(cb_group, true),
-      std::runtime_error(
-        "Failed to handle entities update on callback group remove: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, remove_node_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.remove_node(node, true),
-      std::runtime_error("Node '/ns/node' needs to be associated with an executor."));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, remove_node_trigger_guard_failed) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-
-  executor.add_node(node);
-
-  {
-    auto mock = mocking_utils::patch_and_return(
-      "lib:rclcpp", rcl_trigger_guard_condition, RCL_RET_ERROR);
-    RCLCPP_EXPECT_THROW_EQ(
-      executor.remove_node(node, true),
-      std::runtime_error("Failed to handle entities update on node remove: error not set"));
-  }
-}
-
-TEST_F(TestStaticSingleThreadedExecutor, execute_service) {
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-  DeprecatedStaticSingleThreadedExecutor executor;
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-  auto node = std::make_shared<rclcpp::Node>("node", "ns");
-  executor.add_node(node);
-
-  auto service =
-    node->create_service<test_msgs::srv::Empty>(
-    "service",
-    [](
-      const test_msgs::srv::Empty::Request::SharedPtr,
-      test_msgs::srv::Empty::Response::SharedPtr) {});
-  auto client = node->create_client<test_msgs::srv::Empty>("service");
-
-  std::promise<void> promise;
-  std::future<void> future = promise.get_future();
-  EXPECT_EQ(
-    rclcpp::FutureReturnCode::TIMEOUT,
-    executor.spin_until_future_complete(future, std::chrono::milliseconds(1)));
-
-  executor.remove_node(node);
-  executor.spin_until_future_complete(future, std::chrono::milliseconds(1));
-}

rclcpp/test/rclcpp/executors/test_waitable.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include <atomic>
+#include <chrono>
 #include <functional>
 #include <memory>
 #include <thread>

rclcpp/test/rclcpp/node_interfaces/test_node_graph.cpp

@@ -510,7 +510,9 @@ TEST_F(TestNodeGraph, get_node_names_and_namespaces_fini_errors)
     "lib:rclcpp", rcutils_string_array_fini, RCL_RET_ERROR);
   RCLCPP_EXPECT_THROW_EQ(
     node_graph()->get_node_names_and_namespaces(),
-    std::runtime_error("could not destroy node names, could not destroy node namespaces"));
+    std::runtime_error(
+    "could not destroy node names: error not set, "
+    "could not destroy node namespaces: error not set"));
 }
 
 TEST_F(TestNodeGraph, get_node_names_with_enclaves_fini_errors)

rclcpp/test/rclcpp/node_interfaces/test_node_parameters.cpp

@@ -128,7 +128,7 @@ TEST_F(TestNodeParameters, list_parameters)
     list_result5.names.end());
 }
 
-TEST_F(TestNodeParameters, parameter_overrides)
+TEST_F(TestNodeParameters, parameter_overrides_with_value)
 {
   rclcpp::NodeOptions node_options;
   node_options.automatically_declare_parameters_from_overrides(true);
@@ -146,6 +146,24 @@ TEST_F(TestNodeParameters, parameter_overrides)
   EXPECT_EQ(2u, parameter_overrides.size());
 }
 
+TEST_F(TestNodeParameters, parameter_overrides_with_parameter)
+{
+  rclcpp::NodeOptions node_options;
+  node_options.automatically_declare_parameters_from_overrides(true);
+  node_options.append_parameter_override(rclcpp::Parameter("param1", true));
+  node_options.append_parameter_override(rclcpp::Parameter("param2", 42));
+
+  std::shared_ptr<rclcpp::Node> node2 = std::make_shared<rclcpp::Node>("node2", "ns", node_options);
+
+  auto * node_parameters_interface =
+    dynamic_cast<rclcpp::node_interfaces::NodeParameters *>(
+    node2->get_node_parameters_interface().get());
+  ASSERT_NE(nullptr, node_parameters_interface);
+
+  const auto & parameter_overrides = node_parameters_interface->get_parameter_overrides();
+  EXPECT_EQ(2u, parameter_overrides.size());
+}
+
 TEST_F(TestNodeParameters, set_parameters) {
   rclcpp::NodeOptions node_options;
   node_options.allow_undeclared_parameters(true);

rclcpp/test/rclcpp/node_interfaces/test_node_type_descriptions.cpp

@@ -37,6 +37,38 @@ TEST_F(TestNodeTypeDescriptions, interface_created)
   ASSERT_NE(nullptr, node.get_node_type_descriptions_interface());
 }
 
+TEST_F(TestNodeTypeDescriptions, automatically_declare_parameters_from_overrides)
+{
+  rclcpp::NodeOptions node_options;
+  node_options.automatically_declare_parameters_from_overrides(true);
+  node_options.append_parameter_override("start_type_description_service", false);
+  ASSERT_NO_THROW(
+  {
+    auto node = std::make_shared<rclcpp::Node>("node", "ns", node_options);
+    (void) node;
+  });
+}
+
+TEST_F(TestNodeTypeDescriptions, bad_parameter_type)
+{
+  rclcpp::NodeOptions node_options;
+  node_options.append_parameter_override("start_type_description_service", "unexpected_type");
+
+  ASSERT_THROW(
+  {
+    node_options.automatically_declare_parameters_from_overrides(false);
+    auto node = std::make_shared<rclcpp::Node>("node", "ns", node_options);
+    (void) node;
+  }, rclcpp::exceptions::InvalidParameterTypeException);
+
+  ASSERT_THROW(
+  {
+    node_options.automatically_declare_parameters_from_overrides(true);
+    auto node = std::make_shared<rclcpp::Node>("node", "ns", node_options);
+    (void) node;
+  }, rclcpp::exceptions::InvalidParameterTypeException);
+}
+
 TEST_F(TestNodeTypeDescriptions, disabled_no_service)
 {
   rclcpp::NodeOptions node_options;

rclcpp/test/rclcpp/test_client_common.cpp

@@ -112,10 +112,12 @@ protected:
     auto req_id = client->async_send_request(request, std::move(callback));
 
     auto start = std::chrono::steady_clock::now();
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node);
     while (!received_response &&
       (std::chrono::steady_clock::now() - start) < timeout)
     {
-      rclcpp::spin_some(node);
+      executor.spin_some();
     }
 
     if (!received_response) {
@@ -356,10 +358,12 @@ TYPED_TEST(TestAllClientTypesWithServer, on_new_response_callback)
 
   this->template async_send_request<ClientType, test_msgs::srv::Empty::Request>(client, request);
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(server_node);
   while (server_requests_count == 0 &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(10))
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(server_requests_count, 1u);
@@ -380,7 +384,7 @@ TYPED_TEST(TestAllClientTypesWithServer, on_new_response_callback)
   while (server_requests_count == 1 &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(10))
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(server_requests_count, 2u);
@@ -402,7 +406,7 @@ TYPED_TEST(TestAllClientTypesWithServer, on_new_response_callback)
   while (server_requests_count < 5 &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(10))
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(server_requests_count, 5u);
@@ -492,10 +496,12 @@ void client_async_send_request_callback_with_request(
   auto req_id = client->async_send_request(request, std::move(callback));
 
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   while (!received_response &&
     (std::chrono::steady_clock::now() - start) < std::chrono::seconds(1))
   {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_TRUE(received_response);
   EXPECT_FALSE(client->remove_pending_request(req_id));
@@ -553,25 +559,29 @@ void client_qos_depth(rclcpp::Node::SharedPtr node)
   }
 
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor server_executor;
+  server_executor.add_node(server_node);
   while ((server_cb_count_ < client_requests) &&
     (std::chrono::steady_clock::now() - start) < 2s)
   {
-    rclcpp::spin_some(server_node);
+    server_executor.spin_some();
     std::this_thread::sleep_for(2ms);
   }
 
   EXPECT_GT(server_cb_count_, client_qos_profile.depth());
 
   start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor client_executor;
+  client_executor.add_node(node);
   while ((client_cb_count_ < client_qos_profile.depth()) &&
     (std::chrono::steady_clock::now() - start) < 1s)
   {
-    rclcpp::spin_some(node);
+    client_executor.spin_some();
   }
 
   // Spin an extra time to check if client QoS depth has been ignored,
   // so more client callbacks might be called than expected.
-  rclcpp::spin_some(node);
+  client_executor.spin_some();
 
   EXPECT_EQ(client_cb_count_, client_qos_profile.depth());
 }

rclcpp/test/rclcpp/test_create_timer.cpp

@@ -42,7 +42,9 @@ TEST(TestCreateTimer, timer_executes)
       timer->cancel();
     });
 
-  rclcpp::spin_some(node);
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+  executor.spin_some();
 
   ASSERT_TRUE(got_callback);
   rclcpp::shutdown();

rclcpp/test/rclcpp/test_generic_pubsub.cpp

@@ -15,6 +15,7 @@
 
 #include <gmock/gmock.h>
 
+#include <chrono>
 #include <future>
 #include <memory>
 #include <string>
@@ -77,8 +78,10 @@ public:
         counter++;
       });
 
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node_);
     while (counter < expected_recv_msg_count) {
-      rclcpp::spin_some(node_);
+      executor.spin_some();
     }
     return messages;
   }
@@ -106,11 +109,13 @@ public:
   {
     using clock = std::chrono::system_clock;
     auto start = clock::now();
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node_);
     while (!condition()) {
       if ((clock::now() - start) > timeout) {
         return false;
       }
-      rclcpp::spin_some(node_);
+      executor.spin_some();
     }
     return true;
   }

rclcpp/test/rclcpp/test_generic_service.cpp

@@ -372,16 +372,18 @@ TEST_F(TestGenericService, generic_service_qos_depth) {
   }
 
   auto start = std::chrono::steady_clock::now();
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(server_node);
   while ((server_cb_count_ < server_qos_profile.depth()) &&
     (std::chrono::steady_clock::now() - start) < 1s)
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
     std::this_thread::sleep_for(1ms);
   }
 
   // Spin an extra time to check if server QoS depth has been ignored,
   // so more server responses might be processed than expected.
-  rclcpp::spin_some(server_node);
+  executor.spin_some();
 
   EXPECT_EQ(server_cb_count_, server_qos_profile.depth());
 }

rclcpp/test/rclcpp/test_graph_listener.cpp

@@ -43,9 +43,7 @@ public:
     node_graph_ = node_->get_node_graph_interface();
     ASSERT_NE(nullptr, node_graph_);
 
-    graph_listener_ =
-      std::make_shared<rclcpp::graph_listener::GraphListener>(
-      rclcpp::contexts::get_global_default_context());
+    graph_listener_ = rclcpp::contexts::get_global_default_context()->get_graph_listener();
   }
 
   void TearDown()

rclcpp/test/rclcpp/test_logger_service.cpp

@@ -14,6 +14,7 @@
 
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include <memory>
 #include <string>
 #include <vector>

rclcpp/test/rclcpp/test_logging.cpp

@@ -253,9 +253,19 @@ bool log_function_const_ref(const rclcpp::Logger & logger)
   return true;
 }
 
+class DerivedLogger : public rclcpp::Logger
+{
+public:
+  explicit DerivedLogger(const rclcpp::Logger & logger)
+  : rclcpp::Logger(logger) {}
+};
+
 TEST_F(TestLoggingMacros, test_log_from_node) {
   auto logger = rclcpp::get_logger("test_logging_logger");
   EXPECT_TRUE(log_function(logger));
   EXPECT_TRUE(log_function_const(logger));
   EXPECT_TRUE(log_function_const_ref(logger));
+
+  DerivedLogger derived_logger(logger);
+  RCLCPP_INFO(derived_logger, "successful log from derived logger");
 }

rclcpp/test/rclcpp/test_memory_strategy.cpp

@@ -129,6 +129,8 @@ TEST_F(TestMemoryStrategy, get_subscription_by_handle) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_subscription_by_handle(subscription_handle, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,
@@ -181,6 +183,8 @@ TEST_F(TestMemoryStrategy, get_service_by_handle) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_service_by_handle(service_handle, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,
@@ -228,6 +232,11 @@ TEST_F(TestMemoryStrategy, get_client_by_handle) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_client_by_handle(client_handle, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
+    // reset client handle before node destruction, otherwise it tries to access node
+    // via weak_ptr in its deleter
+    client_handle.reset();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,
@@ -276,6 +285,8 @@ TEST_F(TestMemoryStrategy, get_timer_by_handle) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_timer_by_handle(timer_handle, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,
@@ -375,6 +386,8 @@ TEST_F(TestMemoryStrategy, get_group_by_subscription) {
     EXPECT_EQ(
       callback_group,
       memory_strategy()->get_group_by_subscription(subscription, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   // NodeBase(SubscriptionBase->rcl_node_t->NodeBase) is still alive.
   EXPECT_EQ(
@@ -420,6 +433,8 @@ TEST_F(TestMemoryStrategy, get_group_by_service) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_group_by_service(service, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,
@@ -459,6 +474,8 @@ TEST_F(TestMemoryStrategy, get_group_by_client) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_group_by_client(client, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,
@@ -498,6 +515,8 @@ TEST_F(TestMemoryStrategy, get_group_by_timer) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_group_by_timer(timer, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,
@@ -536,6 +555,8 @@ TEST_F(TestMemoryStrategy, get_group_by_waitable) {
     EXPECT_EQ(
       nullptr,
       memory_strategy()->get_group_by_waitable(waitable, weak_groups_to_nodes));
+    // Clear all handles to cleanup when node is destroyed
+    memory_strategy()->clear_handles();
   }  // Node goes out of scope
   EXPECT_EQ(
     nullptr,

rclcpp/test/rclcpp/test_node_options.cpp

@@ -258,8 +258,10 @@ TEST(TestNodeOptions, append_parameter_override) {
   auto options = rclcpp::NodeOptions().arguments(expected_args).use_global_arguments(false);
   rclcpp::Parameter parameter("some_parameter", 10);
   options.append_parameter_override("some_parameter", 10);
-  EXPECT_EQ(1u, options.parameter_overrides().size());
+  options.append_parameter_override(parameter);
+  EXPECT_EQ(2u, options.parameter_overrides().size());
   EXPECT_EQ(std::string("some_parameter"), options.parameter_overrides()[0].get_name());
+  EXPECT_EQ(std::string("some_parameter"), options.parameter_overrides()[1].get_name());
 }
 
 TEST(TestNodeOptions, rcl_node_options_fini_error) {

rclcpp/test/rclcpp/test_parameter_service.cpp

@@ -14,6 +14,7 @@
 
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include <memory>
 #include <string>
 #include <utility>

rclcpp/test/rclcpp/test_publisher.cpp

@@ -199,7 +199,7 @@ TEST_F(TestPublisher, test_publisher_with_system_default_qos) {
   using test_msgs::msg::Empty;
   ASSERT_NO_THROW(
   {
-    auto publisher = node->create_publisher<Empty>("topic", rclcpp::SystemDefaultsQoS());
+    auto publisher = node->create_publisher<Empty>("topic", rclcpp::SystemDefaultsQoS(), options);
   });
 }
 

rclcpp/test/rclcpp/test_qos.cpp

@@ -272,3 +272,15 @@ TEST(TestQoS, qos_check_compatible)
     }
   }
 }
+
+TEST(TestQoS, from_rmw_validity)
+{
+  rmw_qos_profile_t invalid_qos;
+  memset(&invalid_qos, 0, sizeof(invalid_qos));
+  unsigned int n = 999;
+  memcpy(&invalid_qos.history, &n, sizeof(n));
+
+  EXPECT_THROW({
+    rclcpp::QoSInitialization::from_rmw(invalid_qos);
+  }, std::invalid_argument);
+}

rclcpp/test/rclcpp/test_rate.cpp

@@ -173,3 +173,12 @@ TEST_F(TestRate, incorrect_constuctor) {
     rclcpp::Rate rate(rclcpp::Duration(-1, 0)),
     std::invalid_argument("period must be greater than 0"));
 }
+
+TEST(TestRateBasic, invalid_context) {
+  rclcpp::init(0, nullptr);
+  rclcpp::Rate rate(1.0);
+  ASSERT_TRUE(rate.sleep());
+  rclcpp::shutdown();
+  EXPECT_NO_THROW(rate.sleep());
+  ASSERT_FALSE(rate.sleep());
+}

rclcpp/test/rclcpp/test_ring_buffer_implementation.cpp

@@ -164,3 +164,15 @@ TEST(TestRingBufferImplementation, test_buffer_clear) {
   EXPECT_EQ('c', c);
   EXPECT_EQ('d', d);
 }
+
+TEST(TestRingBufferImplementation, handle_nullptr_deletion) {
+  rclcpp::experimental::buffers::RingBufferImplementation<std::unique_ptr<int>> rb(3);
+  rb.enqueue(std::make_unique<int>(42));
+  rb.enqueue(nullptr);  // intentionally enqueuing nullptr
+  rb.enqueue(std::make_unique<int>(84));
+  auto all_data = rb.get_all_data();
+  EXPECT_EQ(3u, all_data.size());
+  EXPECT_EQ(42, *(all_data[0]));
+  EXPECT_EQ(nullptr, all_data[1]);
+  EXPECT_EQ(84, *(all_data[2]));
+}

rclcpp/test/rclcpp/test_service.cpp

@@ -14,6 +14,7 @@
 
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include <string>
 #include <memory>
 #include <utility>
@@ -385,17 +386,20 @@ TEST_F(TestService, server_qos_depth) {
     std::this_thread::sleep_for(10ms);
   }
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(server_node);
+
   auto start = std::chrono::steady_clock::now();
   while ((server_cb_count_ < server_qos_profile.depth()) &&
     (std::chrono::steady_clock::now() - start) < 1s)
   {
-    rclcpp::spin_some(server_node);
+    executor.spin_some();
     std::this_thread::sleep_for(1ms);
   }
 
   // Spin an extra time to check if server QoS depth has been ignored,
   // so more server responses might be processed than expected.
-  rclcpp::spin_some(server_node);
+  executor.spin_some();
 
   EXPECT_EQ(server_cb_count_, server_qos_profile.depth());
 }

rclcpp/test/rclcpp/test_service_introspection.cpp

@@ -15,6 +15,7 @@
 #include <rcl/service_introspection.h>
 #include <rmw/rmw.h>
 
+#include <chrono>
 #include <map>
 #include <string>
 
@@ -86,6 +87,9 @@ protected:
 
 TEST_F(TestServiceIntrospection, service_introspection_nominal)
 {
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   auto request = std::make_shared<BasicTypes::Request>();
   request->set__bool_value(true);
   request->set__int64_value(42);
@@ -105,7 +109,7 @@ TEST_F(TestServiceIntrospection, service_introspection_nominal)
   auto future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
 
   BasicTypes::Response::SharedPtr response = future.get();
   ASSERT_EQ(response->bool_value, false);
@@ -114,7 +118,7 @@ TEST_F(TestServiceIntrospection, service_introspection_nominal)
   // wrap up work to get all the service_event messages
   auto start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   std::map<uint8_t, std::shared_ptr<const BasicTypes::Event>> event_map;
@@ -173,6 +177,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   service->configure_introspection(
     node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_OFF);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   ASSERT_EQ(sub->get_publisher_count(), 0);
 
   auto request = std::make_shared<BasicTypes::Request>();
@@ -181,10 +188,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   auto future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   auto start = std::chrono::steady_clock::now();
   while ((std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 0U);
 
@@ -205,10 +212,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 2 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 2U);
 
@@ -229,10 +236,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 2 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 2U);
 
@@ -253,10 +260,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_events)
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
 }
@@ -268,6 +275,9 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   service->configure_introspection(
     node->get_clock(), rclcpp::ServicesQoS(), RCL_SERVICE_INTROSPECTION_METADATA);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   // Wait for the introspection to attach to our subscription
   size_t tries = 1000;
   while (this->sub->get_publisher_count() < 2 && tries-- > 0) {
@@ -281,10 +291,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   auto future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   auto start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {
@@ -309,10 +319,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {
@@ -349,10 +359,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {
@@ -389,10 +399,10 @@ TEST_F(TestServiceIntrospection, service_introspection_enable_disable_event_cont
   future = client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future, timeout));
+    executor.spin_until_future_complete(future, timeout));
   start = std::chrono::steady_clock::now();
   while (events.size() < 4 && (std::chrono::steady_clock::now() - start) < timeout) {
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
   EXPECT_EQ(events.size(), 4U);
   for (const auto & event : events) {

rclcpp/test/rclcpp/test_subscription_content_filter.cpp

@@ -69,11 +69,13 @@ public:
   {
     using clock = std::chrono::system_clock;
     auto start = clock::now();
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node);
     while (!condition()) {
       if ((clock::now() - start) > timeout) {
         return false;
       }
-      rclcpp::spin_some(node);
+      executor.spin_some();
     }
     return true;
   }

rclcpp/test/rclcpp/test_typesupport_helpers.cpp

@@ -158,3 +158,15 @@ TEST(TypesupportHelpersTest, test_throw_exception_with_invalid_type) {
     rclcpp::get_action_typesupport_handle(invalid_type, "rosidl_typesupport_cpp", *library),
     std::runtime_error);
 }
+
+TEST(TypesupportHelpersTest, throws_exception_if_filetype_has_multiple_slashes_at_start) {
+  EXPECT_ANY_THROW(rclcpp::extract_type_identifier("//name_with_slashes_at_start"));
+}
+
+TEST(TypesupportHelpersTestV3, ProcessesValidTypeWithWhitespace) {
+  std::string package, middle, name;
+  std::tie(package, middle, name) = rclcpp::extract_type_identifier("   package/  name  ");
+  EXPECT_EQ(package, "package");
+  EXPECT_TRUE(middle.empty());
+  EXPECT_EQ(name, "name");
+}

rclcpp/test/rclcpp/test_wait_for_message.cpp

@@ -14,6 +14,7 @@
 
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include <memory>
 #include <string>
 #include <vector>
@@ -107,3 +108,29 @@ TEST(TestUtilities, wait_for_message_twice_one_sub) {
 
   rclcpp::shutdown();
 }
+
+TEST(TestUtilities, wait_for_last_message) {
+  rclcpp::init(0, nullptr);
+
+  auto node = std::make_shared<rclcpp::Node>("wait_for_last_message_node");
+  auto qos = rclcpp::QoS(1).reliable().transient_local();
+
+  using MsgT = test_msgs::msg::Strings;
+  auto pub = node->create_publisher<MsgT>("wait_for_last_message_topic", qos);
+  pub->publish(*get_messages_strings()[0]);
+
+  MsgT out;
+  auto received = false;
+  auto wait = std::async(
+    [&]() {
+      auto ret = rclcpp::wait_for_message(out, node, "wait_for_last_message_topic", 5s, qos);
+      EXPECT_TRUE(ret);
+      received = true;
+    });
+
+  ASSERT_NO_THROW(wait.get());
+  ASSERT_TRUE(received);
+  EXPECT_EQ(out, *get_messages_strings()[0]);
+
+  rclcpp::shutdown();
+}

rclcpp_action/CHANGELOG.rst

@@ -3,6 +3,31 @@ Changelog for package rclcpp_action
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
+30.1.2 (2025-10-21)
+-------------------
+* it misses the iterator second to lock the weakptr. (`#2958 <https://github.com/ros2/rclcpp/issues/2958>`_)
+* try aborting before canceling 1st on dtor of ServerGoalHandle. (`#2953 <https://github.com/ros2/rclcpp/issues/2953>`_)
+* Contributors: Tomoya Fujita
+
+30.1.1 (2025-09-11)
+-------------------
+* deprecate rclcpp::spin_some and rclcpp::spin_all (`#2848 <https://github.com/ros2/rclcpp/issues/2848>`_)
+* Contributors: Alberto Soragna
+
+30.1.0 (2025-07-29)
+-------------------
+* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_)
+* Contributors: mosfet80
+
+30.0.0 (2025-07-01)
+-------------------
+
+29.6.1 (2025-06-23)
+-------------------
+* Replace std::default_random_engine with std::mt19937 (rolling) (`#2843 <https://github.com/ros2/rclcpp/issues/2843>`_)
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* Contributors: Alejandro Hernández Cordero, keeponoiro
+
 29.6.0 (2025-04-25)
 -------------------
 

rclcpp_action/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.20)
 
 project(rclcpp_action)
 

rclcpp_action/include/rclcpp_action/client.hpp

@@ -350,7 +350,7 @@ public:
         return;
       }
 
-      goal_handle = it->lock();
+      goal_handle = it->second.lock();
     }
 
     if (goal_handle) {

rclcpp_action/include/rclcpp_action/server_goal_handle.hpp

@@ -24,6 +24,8 @@
 
 #include "action_msgs/msg/goal_status.hpp"
 
+#include "rclcpp/logging.hpp"
+
 #include "rclcpp_action/visibility_control.hpp"
 #include "rclcpp_action/types.hpp"
 
@@ -103,11 +105,19 @@ protected:
   _execute();
 
   /// Transition the goal to canceled state if it never reached a terminal state.
+  /// Returns true if transitioned to canceled, else false.
   /// \internal
   RCLCPP_ACTION_PUBLIC
   bool
   try_canceling() noexcept;
 
+  /// Transition the goal to aborted state if it never reached a terminal state.
+  /// Returns true if transitioned to aborted, else false.
+  /// \internal
+  RCLCPP_ACTION_PUBLIC
+  bool
+  try_aborting() noexcept;
+
   // End API for communication between ServerGoalHandleBase and ServerGoalHandle<>
   // -----------------------------------------------------------------------------
 
@@ -243,11 +253,22 @@ public:
 
   virtual ~ServerGoalHandle()
   {
-    // Cancel goal if handle was allowed to destruct without reaching a terminal state
-    if (try_canceling()) {
-      auto null_result = std::make_shared<typename ActionT::Impl::GetResultService::Response>();
-      null_result->status = action_msgs::msg::GoalStatus::STATUS_CANCELED;
-      on_terminal_state_(uuid_, null_result);
+    try {
+      // Abort goal if handle was allowed to destruct without reaching a terminal state
+      if (try_aborting()) {
+        auto null_result = std::make_shared<typename ActionT::Impl::GetResultService::Response>();
+        null_result->status = action_msgs::msg::GoalStatus::STATUS_ABORTED;
+        on_terminal_state_(uuid_, null_result);
+      } else if (try_canceling()) {
+        // Cancel goal if handle was allowed to destruct without reaching a terminal state
+        auto null_result = std::make_shared<typename ActionT::Impl::GetResultService::Response>();
+        null_result->status = action_msgs::msg::GoalStatus::STATUS_CANCELED;
+        on_terminal_state_(uuid_, null_result);
+      }
+    } catch (const std::exception & ex) {
+      RCLCPP_DEBUG(
+        rclcpp::get_logger("rclcpp_action"),
+        "Failed to abort/cancel goal handler in destructor: %s", ex.what());
     }
   }
 

rclcpp_action/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp_action</name>
-  <version>29.6.0</version>
+  <version>30.1.2</version>
   <description>Adds action APIs for C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp_action/src/client_base.cpp

@@ -181,7 +181,7 @@ public:
   std::recursive_mutex cancel_requests_mutex;
 
   std::independent_bits_engine<
-    std::default_random_engine, 8, unsigned int> random_bytes_generator;
+    std::mt19937, 8, unsigned int> random_bytes_generator;
 };
 
 ClientBase::ClientBase(

rclcpp_action/src/server_goal_handle.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include <memory>
+#include <mutex>
 
 #include "rcl_action/action_server.h"
 #include "rcl_action/goal_handle.h"
@@ -135,6 +136,24 @@ ServerGoalHandleBase::try_canceling() noexcept
     return RCL_RET_OK == ret;
   }
 
-  return false;
+  return is_cancelable;
+}
+
+bool
+ServerGoalHandleBase::try_aborting() noexcept
+{
+  std::lock_guard<std::mutex> lock(rcl_handle_mutex_);
+  rcl_ret_t ret;
+  // Check if the goal is abortable
+  const bool is_abortable = rcl_action_goal_handle_is_abortable(rcl_handle_.get());
+  if (is_abortable) {
+    // Transition to ABORTED
+    ret = rcl_action_update_goal_state(rcl_handle_.get(), GOAL_EVENT_ABORT);
+    if (RCL_RET_OK != ret) {
+      return false;
+    }
+  }
+
+  return is_abortable;
 }
 }  // namespace rclcpp_action

rclcpp_action/test/test_client.cpp

@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <chrono>
 #include <future>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <thread>
-#include <chrono>
 
 #include "gtest/gtest.h"
 

rclcpp_action/test/test_server.cpp

@@ -518,9 +518,11 @@ TEST_F(TestServer, publish_status_accepted)
 
   // 10 seconds
   const size_t max_tries = 10 * 1000 / 100;
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   for (size_t retry = 0; retry < max_tries && received_msgs.size() != 1u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -582,9 +584,11 @@ TEST_F(TestServer, publish_status_canceling)
 
   // 10 seconds
   const size_t max_tries = 10 * 1000 / 100;
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 2u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -640,10 +644,12 @@ TEST_F(TestServer, publish_status_canceled)
   received_handle->canceled(std::make_shared<Fibonacci::Result>());
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 3u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -697,10 +703,12 @@ TEST_F(TestServer, publish_status_succeeded)
   received_handle->succeed(std::make_shared<Fibonacci::Result>());
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 2u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -754,10 +762,12 @@ TEST_F(TestServer, publish_status_aborted)
   received_handle->abort(std::make_shared<Fibonacci::Result>());
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 2u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_LT(0u, received_msgs.size());
@@ -814,10 +824,12 @@ TEST_F(TestServer, publish_feedback)
   received_handle->publish_feedback(sent_message);
 
   // 10 seconds
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
   const size_t max_tries = 10 * 1000 / 100;
   for (size_t retry = 0; retry < max_tries && received_msgs.size() < 1u; ++retry) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    rclcpp::spin_some(node);
+    executor.spin_some();
   }
 
   ASSERT_EQ(1u, received_msgs.size());
@@ -878,10 +890,13 @@ TEST_F(TestServer, get_result)
   result->sequence = {5, 8, 13, 21};
   received_handle->succeed(result);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   // Wait for the result request to be received
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future));
+    executor.spin_until_future_complete(future));
 
   auto response = future.get();
   EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_SUCCEEDED, response->status);
@@ -891,13 +906,13 @@ TEST_F(TestServer, get_result)
   rclcpp::sleep_for(2 * result_timeout);
 
   // Allow for expiration to take place
-  rclcpp::spin_some(node);
+  executor.spin_some();
 
   // Send and wait for another result request
   future = result_client->async_send_request(request);
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future));
+    executor.spin_until_future_complete(future));
 
   response = future.get();
   EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_UNKNOWN, response->status);
@@ -946,9 +961,12 @@ TEST_F(TestServer, get_result_deferred)
   request->goal_id.uuid = uuid;
   auto future = result_client->async_send_request(request);
 
+  rclcpp::executors::SingleThreadedExecutor executor;
+  executor.add_node(node);
+
   // Process request first
   rclcpp::sleep_for(std::chrono::milliseconds(10));  // Give a chance for the request to be served
-  rclcpp::spin_some(node);
+  executor.spin_some();
 
   // Send a result
   auto result = std::make_shared<Fibonacci::Result>();
@@ -958,7 +976,7 @@ TEST_F(TestServer, get_result_deferred)
   // Wait for the result request to be received
   ASSERT_EQ(
     rclcpp::FutureReturnCode::SUCCESS,
-    rclcpp::spin_until_future_complete(node, future));
+    executor.spin_until_future_complete(future));
 
   auto response = future.get();
   EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_SUCCEEDED, response->status);
@@ -1042,10 +1060,13 @@ public:
     result->sequence = {5, 8, 13, 21};
     goal_handle_->succeed(result);
 
+    rclcpp::executors::SingleThreadedExecutor executor;
+    executor.add_node(node_);
+
     // Wait for the result request to be received
     ASSERT_EQ(
       rclcpp::FutureReturnCode::SUCCESS,
-      rclcpp::spin_until_future_complete(node_, future));
+      executor.spin_until_future_complete(future));
 
     auto response = future.get();
     EXPECT_EQ(action_msgs::msg::GoalStatus::STATUS_SUCCEEDED, response->status);
@@ -1055,13 +1076,13 @@ public:
     rclcpp::sleep_for(std::chrono::milliseconds(100));
 
     // Allow for expiration to take place
-    rclcpp::spin_some(node_);
+    executor.spin_some();
 
     // Send and wait for another result request
     future = result_client->async_send_request(request);
     ASSERT_EQ(
       rclcpp::FutureReturnCode::SUCCESS,
-      rclcpp::spin_until_future_complete(node_, future));
+      executor.spin_until_future_complete(future));
   }
 
 protected:

rclcpp_action/test/test_server_goal_handle.cpp

@@ -44,6 +44,8 @@ public:
 
   bool try_cancel() {return try_canceling();}
 
+  bool try_abort() {return try_aborting();}
+
   void cancel_goal() {_cancel_goal();}
 };
 
@@ -132,6 +134,20 @@ TEST_F(TestServerGoalHandle, abort) {
   EXPECT_THROW(handle_->abort(result), rclcpp::exceptions::RCLError);
 }
 
+TEST_F(TestServerGoalHandle, try_abort) {
+  handle_->execute();
+  test_msgs::action::Fibonacci::Result::SharedPtr result =
+    std::make_shared<test_msgs::action::Fibonacci::Result>();
+  EXPECT_TRUE(handle_->try_abort());
+  EXPECT_FALSE(handle_->is_canceling());
+  EXPECT_FALSE(handle_->is_active());
+  EXPECT_FALSE(handle_->is_executing());
+
+  auto mock = mocking_utils::patch_and_return(
+    "lib:rclcpp_action", rcl_action_update_goal_state, RCL_RET_ERROR);
+  EXPECT_THROW(handle_->abort(result), rclcpp::exceptions::RCLError);
+}
+
 TEST_F(TestServerGoalHandle, succeed) {
   handle_->execute();
   test_msgs::action::Fibonacci::Result::SharedPtr result =

rclcpp_action/test/test_types.cpp

@@ -67,7 +67,7 @@ TEST(TestActionTypes, goal_uuid_to_hashed_uuid_random) {
   // Use std::random_device to seed the generator of goal IDs.
   std::random_device rd;
   std::independent_bits_engine<
-    std::default_random_engine, 8, decltype(rd())> random_bytes_generator(rd());
+    std::mt19937, 8, decltype(rd())> random_bytes_generator(rd());
 
   std::vector<size_t> hashed_guuids;
   constexpr size_t iterations = 1000;

rclcpp_components/CHANGELOG.rst

@@ -2,6 +2,31 @@
 Changelog for package rclcpp_components
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+30.1.2 (2025-10-21)
+-------------------
+
+30.1.1 (2025-09-11)
+-------------------
+* Cleanup the dependencies in rclcpp_components. (`#2918 <https://github.com/ros2/rclcpp/issues/2918>`_)
+* Contributors: Chris Lalancette
+
+30.1.0 (2025-07-29)
+-------------------
+* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_)
+* Contributors: mosfet80
+
+30.0.0 (2025-07-01)
+-------------------
+* NEW PR: Add component_container for EventsExecutor (`#2885 <https://github.com/ros2/rclcpp/issues/2885>`_)
+* make sure that plugin arg includes the double colon. (`#2878 <https://github.com/ros2/rclcpp/issues/2878>`_)
+* Contributors: Mihir Rao, Tomoya Fujita
+
+29.6.1 (2025-06-23)
+-------------------
+* set thread names by node in component container isolated (`#2871 <https://github.com/ros2/rclcpp/issues/2871>`_)
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* Contributors: Adam Aposhian, Alejandro Hernández Cordero
+
 29.6.0 (2025-04-25)
 -------------------
 

rclcpp_components/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.20)
 
 project(rclcpp_components)
 
@@ -19,7 +19,9 @@ find_package(ament_index_cpp REQUIRED)
 find_package(class_loader REQUIRED)
 find_package(composition_interfaces REQUIRED)
 find_package(rclcpp REQUIRED)
+find_package(rcl_interfaces REQUIRED)
 find_package(rcpputils REQUIRED)
+find_package(rmw REQUIRED)
 
 # Add an interface library that can be depended upon by libraries who register components
 add_library(component INTERFACE)
@@ -39,13 +41,15 @@ target_include_directories(component_manager PUBLIC
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
   "$<INSTALL_INTERFACE:include/${PROJECT_NAME}>")
 target_link_libraries(component_manager PUBLIC
+  class_loader::class_loader
   ${composition_interfaces_TARGETS}
   rclcpp::rclcpp
+  rmw::rmw
 )
 target_link_libraries(component_manager PRIVATE
   ament_index_cpp::ament_index_cpp
-  class_loader::class_loader
   rcpputils::rcpputils
+  ${rcl_interfaces_TARGETS}
 )
 target_compile_definitions(component_manager
   PRIVATE "RCLCPP_COMPONENTS_BUILDING_LIBRARY")
@@ -54,7 +58,13 @@ add_executable(
   component_container
   src/component_container.cpp
 )
-target_link_libraries(component_container component_manager rclcpp::rclcpp)
+target_link_libraries(component_container PRIVATE component_manager rclcpp::rclcpp)
+
+add_executable(
+  component_container_event
+  src/component_container_event.cpp
+)
+target_link_libraries(component_container_event PRIVATE component_manager rclcpp::rclcpp)
 
 set(node_main_template_install_dir "share/${PROJECT_NAME}")
 install(FILES
@@ -65,19 +75,13 @@ add_executable(
   component_container_mt
   src/component_container_mt.cpp
 )
-target_link_libraries(component_container_mt component_manager rclcpp::rclcpp)
+target_link_libraries(component_container_mt PRIVATE component_manager rclcpp::rclcpp)
 
 add_executable(
   component_container_isolated
   src/component_container_isolated.cpp
 )
-target_link_libraries(component_container_isolated component_manager rclcpp::rclcpp)
-
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  target_link_libraries(component_container "stdc++fs")
-  target_link_libraries(component_container_mt "stdc++fs")
-  target_link_libraries(component_container_isolated "stdc++fs")
-endif()
+target_link_libraries(component_container_isolated PRIVATE component_manager rclcpp::rclcpp)
 
 if(BUILD_TESTING)
   find_package(ament_lint_auto REQUIRED)
@@ -145,7 +149,7 @@ install(
 
 # Install executables
 install(
-  TARGETS component_container component_container_mt component_container_isolated
+  TARGETS component_container component_container_mt component_container_isolated component_container_event
   RUNTIME DESTINATION lib/${PROJECT_NAME}
 )
 
@@ -168,9 +172,5 @@ ament_export_libraries(component_manager)
 # Export modern CMake targets
 ament_export_targets(export_${PROJECT_NAME})
 
-# specific order: dependents before dependencies
-ament_export_dependencies(ament_index_cpp)
-ament_export_dependencies(class_loader)
-ament_export_dependencies(composition_interfaces)
-ament_export_dependencies(rclcpp)
+ament_export_dependencies(class_loader composition_interfaces rclcpp rcpputils rmw)
 ament_package(CONFIG_EXTRAS rclcpp_components-extras.cmake.in)

rclcpp_components/cmake/rclcpp_components_register_node.cmake

@@ -57,6 +57,9 @@ macro(rclcpp_components_register_node target)
     message(STATUS "Setting executor non-default value ${executor}")
   endif()
 
+  if("${ARGS_PLUGIN}" MATCHES "^[^:]+:[^:]+$")
+    message(FATAL_ERROR "PLUGIN argument '${ARGS_PLUGIN}' appears to be incorrect. (e.g., 'package_name::ClassName').")
+  endif()
   set(component ${ARGS_PLUGIN})
   set(node ${ARGS_EXECUTABLE})
   _rclcpp_components_register_package_hook()

rclcpp_components/include/rclcpp_components/component_manager.hpp

@@ -43,10 +43,13 @@
 
 #include <map>
 #include <memory>
+#include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "class_loader/class_loader.hpp"
+
 #include "composition_interfaces/srv/load_node.hpp"
 #include "composition_interfaces/srv/unload_node.hpp"
 #include "composition_interfaces/srv/list_nodes.hpp"
@@ -56,12 +59,10 @@
 #include "rclcpp/rclcpp.hpp"
 
 #include "rclcpp_components/node_factory.hpp"
+#include "rclcpp_components/node_instance_wrapper.hpp"
 #include "rclcpp_components/visibility_control.hpp"
 
-namespace class_loader
-{
-class ClassLoader;
-}  // namespace class_loader
+#include "rmw/types.h"
 
 namespace rclcpp_components
 {

rclcpp_components/include/rclcpp_components/component_manager_isolated.hpp

@@ -16,15 +16,22 @@
 #ifndef RCLCPP_COMPONENTS__COMPONENT_MANAGER_ISOLATED_HPP__
 #define RCLCPP_COMPONENTS__COMPONENT_MANAGER_ISOLATED_HPP__
 
+#include <atomic>
+#include <chrono>
 #include <map>
 #include <memory>
 #include <string>
+#include <thread>
+#include <unordered_map>
 #include <utility>
 #include <vector>
-#include <unordered_map>
+#include <system_error>
 
+#include "rclcpp/executor.hpp"
+#include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/utilities.hpp"
 #include "rclcpp_components/component_manager.hpp"
-
+#include "rcpputils/thread_name.hpp"
 
 namespace rclcpp_components
 {
@@ -77,8 +84,16 @@ protected:
     DedicatedExecutorWrapper & wrapper = result.first->second;
     wrapper.executor = exec;
     auto & thread_initialized = wrapper.thread_initialized;
+    auto name = node_wrappers_[node_id].get_node_base_interface()->get_name();
+    // Copy name so that it doesn't deallocate before the thread is started
     wrapper.thread = std::thread(
-      [exec, &thread_initialized]() {
+      [exec, &thread_initialized, name]() {
+        try {
+          rcpputils::set_thread_name(name);
+        } catch (const std::system_error & e) {
+          RCLCPP_WARN(rclcpp::get_logger("rclcpp"), "Failed to set thread name: %s (%s)", e.what(),
+            e.code().message().c_str());
+        }
         thread_initialized = true;
         exec->spin();
       });

rclcpp_components/include/rclcpp_components/node_factory_template.hpp

@@ -18,7 +18,10 @@
 #include <functional>
 #include <memory>
 
+#include "rclcpp/node_options.hpp"
+
 #include "rclcpp_components/node_factory.hpp"
+#include "rclcpp_components/node_instance_wrapper.hpp"
 
 namespace rclcpp_components
 {

rclcpp_components/include/rclcpp_components/register_node_macro.hpp

@@ -16,6 +16,7 @@
 #define RCLCPP_COMPONENTS__REGISTER_NODE_MACRO_HPP__
 
 #include "class_loader/class_loader.hpp"
+#include "rclcpp_components/node_factory.hpp"
 #include "rclcpp_components/node_factory_template.hpp"
 
 /// Register a component that can be dynamically loaded at runtime.

rclcpp_components/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp_components</name>
-  <version>29.6.0</version>
+  <version>30.1.2</version>
   <description>Package containing tools for dynamically loadable components</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>
@@ -16,23 +16,32 @@
 
   <buildtool_depend>ament_cmake_ros</buildtool_depend>
 
+  <build_export_depend>class_loader</build_export_depend>
+  <build_export_depend>composition_interfaces</build_export_depend>
+  <build_export_depend>rclcpp</build_export_depend>
+  <build_export_depend>rcpputils</build_export_depend>
+  <build_export_depend>rmw</build_export_depend>
+
   <build_depend>ament_index_cpp</build_depend>
   <build_depend>class_loader</build_depend>
   <build_depend>composition_interfaces</build_depend>
   <build_depend>rclcpp</build_depend>
+  <build_depend>rcl_interfaces</build_depend>
   <build_depend>rcpputils</build_depend>
+  <build_depend>rmw</build_depend>
 
   <exec_depend>ament_index_cpp</exec_depend>
   <exec_depend>class_loader</exec_depend>
   <exec_depend>composition_interfaces</exec_depend>
   <exec_depend>rclcpp</exec_depend>
+  <exec_depend>rcl_interfaces</exec_depend>
+  <exec_depend>rcpputils</exec_depend>
+  <exec_depend>rmw</exec_depend>
 
   <test_depend>ament_cmake_google_benchmark</test_depend>
   <test_depend>ament_cmake_gtest</test_depend>
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
-  <test_depend>launch_testing</test_depend>
-  <test_depend>std_msgs</test_depend>
 
   <export>
     <build_type>ament_cmake</build_type>

rclcpp_components/src/component_container.cpp

@@ -14,7 +14,8 @@
 
 #include <memory>
 
-#include "rclcpp/rclcpp.hpp"
+#include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/utilities.hpp"
 
 #include "rclcpp_components/component_manager.hpp"
 
@@ -26,4 +27,6 @@ int main(int argc, char * argv[])
   auto node = std::make_shared<rclcpp_components::ComponentManager>(exec);
   exec->add_node(node);
   exec->spin();
+
+  return 0;
 }

rclcpp_components/src/component_container_event.cpp

@@ -0,0 +1,32 @@
+// Copyright 2025 Open Source Robotics Foundation, Inc.Add commentMore actions
+//
+// 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.Add commentMore actions
+
+#include <memory>
+
+#include "rclcpp/utilities.hpp"
+#include "rclcpp/experimental/executors/events_executor/events_executor.hpp"
+
+#include "rclcpp_components/component_manager.hpp"
+
+int main(int argc, char * argv[])
+{
+  /// Component container with an events executor.
+  rclcpp::init(argc, argv);
+  auto exec = std::make_shared<rclcpp::experimental::executors::EventsExecutor>();
+  auto node = std::make_shared<rclcpp_components::ComponentManager>(exec);
+  exec->add_node(node);
+  exec->spin();
+
+  return 0;
+}

rclcpp_components/src/component_container_isolated.cpp

@@ -16,8 +16,10 @@
 #include <vector>
 #include <string>
 
-#include "rclcpp/rclcpp.hpp"
+#include "rclcpp/executors/single_threaded_executor.hpp"
+#include "rclcpp/executors/multi_threaded_executor.hpp"
 #include "rclcpp/utilities.hpp"
+
 #include "rclcpp_components/component_manager_isolated.hpp"
 
 int main(int argc, char * argv[])
@@ -46,4 +48,6 @@ int main(int argc, char * argv[])
   }
   exec->add_node(node);
   exec->spin();
+
+  return 0;
 }

rclcpp_components/src/component_container_mt.cpp

@@ -14,7 +14,8 @@
 
 #include <memory>
 
-#include "rclcpp/rclcpp.hpp"
+#include "rclcpp/executors/multi_threaded_executor.hpp"
+#include "rclcpp/utilities.hpp"
 
 #include "rclcpp_components/component_manager.hpp"
 
@@ -35,4 +36,6 @@ int main(int argc, char * argv[])
   }
   exec->add_node(node);
   exec->spin();
+
+  return 0;
 }

rclcpp_components/src/component_manager.cpp

@@ -17,15 +17,29 @@
 #include <filesystem>
 #include <functional>
 #include <memory>
+#include <stdexcept>
+#include <sstream>
 #include <string>
+#include <thread>
 #include <utility>
 #include <vector>
 
 #include "ament_index_cpp/get_resource.hpp"
+
 #include "class_loader/class_loader.hpp"
-#include "rcpputils/filesystem_helper.hpp"
+
+#include "rclcpp/node_options.hpp"
+#include "rclcpp/qos.hpp"
+
+#include "rclcpp_components/node_factory.hpp"
+
+#include "rcl_interfaces/msg/parameter_descriptor.hpp"
+#include "rcl_interfaces/msg/integer_range.hpp"
+
 #include "rcpputils/split.hpp"
 
+#include "rmw/types.h"
+
 using namespace std::placeholders;
 
 namespace rclcpp_components

rclcpp_components/test/test_component_manager_api.cpp

@@ -14,6 +14,7 @@
 
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include <memory>
 #include <string>
 

rclcpp_lifecycle/CHANGELOG.rst

@@ -3,6 +3,30 @@ Changelog for package rclcpp_lifecycle
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
+30.1.2 (2025-10-21)
+-------------------
+
+30.1.1 (2025-09-11)
+-------------------
+* deprecate rclcpp::spin_some and rclcpp::spin_all (`#2848 <https://github.com/ros2/rclcpp/issues/2848>`_)
+* Clearer warning message, the old one lacked information and was perhaps misleading (`#2927 <https://github.com/ros2/rclcpp/issues/2927>`_)
+* Contributors: Alberto Soragna, Peter Mitrano (AR)
+
+30.1.0 (2025-07-29)
+-------------------
+* fix cmake deprecation (`#2914 <https://github.com/ros2/rclcpp/issues/2914>`_)
+  cmake version < then 3.10 is deprecated
+* Contributors: mosfet80
+
+30.0.0 (2025-07-01)
+-------------------
+
+29.6.1 (2025-06-23)
+-------------------
+* Added missing chrono includes (`#2854 <https://github.com/ros2/rclcpp/issues/2854>`_)
+* introduce rcl_lifecycle_get_transition_label_by_id(). (`#2827 <https://github.com/ros2/rclcpp/issues/2827>`_)
+* Contributors: Alejandro Hernández Cordero, Tomoya Fujita
+
 29.6.0 (2025-04-25)
 -------------------
 

rclcpp_lifecycle/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.20)
 
 project(rclcpp_lifecycle)
 

rclcpp_lifecycle/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rclcpp_lifecycle</name>
-  <version>29.6.0</version>
+  <version>30.1.2</version>
   <description>Package containing a prototype for lifecycle implementation</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp_lifecycle/src/lifecycle_node_interface_impl.cpp

@@ -390,6 +390,7 @@ LifecycleNode::LifecycleNodeInterfaceImpl::change_state(
   constexpr bool publish_update = true;
   State initial_state;
   unsigned int current_state_id;
+  const rcl_lifecycle_transition_t * original_transition{nullptr};
 
   {
     std::lock_guard<std::recursive_mutex> lock(state_machine_mutex_);
@@ -405,6 +406,10 @@ LifecycleNode::LifecycleNodeInterfaceImpl::change_state(
     // keep the initial state to pass to a transition callback
     initial_state = State(state_machine_.current_state);
 
+    original_transition =
+      rcl_lifecycle_get_transition_by_id(state_machine_.current_state, transition_id);
+
+
     if (
       rcl_lifecycle_trigger_transition_by_id(
         &state_machine_, transition_id, publish_update) != RCL_RET_OK)
@@ -459,12 +464,15 @@ LifecycleNode::LifecycleNodeInterfaceImpl::change_state(
   // Update the internal current_state_
   current_state_ = State(state_machine_.current_state);
 
-  // error handling ?!
+  // error handling
   // TODO(karsten1987): iterate over possible ret value
   if (cb_return_code == node_interfaces::LifecycleNodeInterface::CallbackReturn::ERROR) {
-    RCLCPP_WARN(
-      node_logging_interface_->get_logger(),
-      "Error occurred while doing error handling.");
+    if (original_transition) {
+      RCLCPP_WARN(
+        node_logging_interface_->get_logger(),
+        "Callback returned ERROR during the transition: %s", original_transition->label);
+    }
+
 
     auto error_cb_code = execute_callback(current_state_id, initial_state);
     auto error_cb_label = get_label_for_return_code(error_cb_code);

rclcpp_lifecycle/test/benchmark/benchmark_lifecycle_client.cpp

@@ -14,6 +14,7 @@
 
 #include <benchmark/benchmark.h>
 
+#include <chrono>
 #include <memory>
 #include <string>
 #include <vector>

rclcpp_lifecycle/test/test_lifecycle_node.cpp

@@ -14,6 +14,7 @@
 
 
 #include <gtest/gtest.h>
+#include <chrono>
 #include <map>
 #include <memory>
 #include <set>

rclcpp_lifecycle/test/test_lifecycle_service_client.cpp

@@ -226,36 +226,28 @@ private:
     rclcpp::init(0, nullptr);
     lifecycle_node_ = std::make_shared<EmptyLifecycleNode>();
     lifecycle_client_ = std::make_shared<LifecycleServiceClient>("client");
-    spinner_ = std::thread(&TestLifecycleServiceClient::spin, this);
+
+    executor_ = std::make_shared<rclcpp::executors::SingleThreadedExecutor>();
+    spinner_ = std::thread([this]() {
+          executor_->add_node(lifecycle_node_->get_node_base_interface());
+          executor_->add_node(lifecycle_client_);
+          executor_->spin();
+    });
   }
 
   void TearDown() override
   {
-    {
-      std::lock_guard<std::mutex> guard(shutdown_mutex_);
-      rclcpp::shutdown();
+    while(!executor_->is_spinning()) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
+    executor_->cancel();
     spinner_.join();
-  }
-
-  void spin()
-  {
-    while (true) {
-      {
-        std::lock_guard<std::mutex> guard(shutdown_mutex_);
-        if (!rclcpp::ok()) {
-          break;
-        }
-        rclcpp::spin_some(lifecycle_node_->get_node_base_interface());
-        rclcpp::spin_some(lifecycle_client_);
-      }
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    }
+    rclcpp::shutdown();
   }
 
   std::shared_ptr<EmptyLifecycleNode> lifecycle_node_;
   std::shared_ptr<LifecycleServiceClient> lifecycle_client_;
-  std::mutex shutdown_mutex_;
+  std::shared_ptr<rclcpp::executors::SingleThreadedExecutor> executor_;
   std::thread spinner_;
 };
 
@@ -455,34 +447,39 @@ TEST_F(TestLifecycleServiceClientRCLErrors, call_services_rcl_errors) {
   auto mock = mocking_utils::patch_and_return(
     "lib:rclcpp_lifecycle", rcl_lifecycle_state_machine_is_initialized, RCL_RET_ERROR);
 
+  rclcpp::executors::SingleThreadedExecutor lifecycle_node_executor;
+  lifecycle_node_executor.add_node(lifecycle_node->get_node_base_interface());
+  rclcpp::executors::SingleThreadedExecutor client_executor;
+  client_executor.add_node(lifecycle_client);
+
   // on_change_state
   lifecycle_client->change_state(
     lifecycle_msgs::msg::Transition::TRANSITION_CONFIGURE);
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_state
   lifecycle_client->get_state();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_avilable_states
   lifecycle_client->get_available_states();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_available_transitions
   lifecycle_client->get_available_transitions();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 
   // on_get_transition_graph
   lifecycle_client->get_transition_graph();
-  rclcpp::spin_some(lifecycle_client);
+  client_executor.spin_some();
   EXPECT_THROW(
-    rclcpp::spin_some(lifecycle_node->get_node_base_interface()), std::runtime_error);
+    lifecycle_node_executor.spin_some(), std::runtime_error);
 }