@wip

Signed-off-by: Michael Carroll <mjcarroll@intrinsic.ai>

rclcpp/CHANGELOG.rst

@@ -2,34 +2,6 @@
 Changelog for package rclcpp
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-21.2.0 (2023-06-07)
--------------------
-* remove nolint since ament_cpplint updated for the c++17 header (`#2198 <https://github.com/ros2/rclcpp/issues/2198>`_)
-* Feature/available capacity of ipm (`#2173 <https://github.com/ros2/rclcpp/issues/2173>`_)
-* add mutex to protect events_executor current entity collection (`#2187 <https://github.com/ros2/rclcpp/issues/2187>`_)
-* Declare rclcpp callbacks before the rcl entities (`#2024 <https://github.com/ros2/rclcpp/issues/2024>`_)
-* Contributors: Alberto Soragna, Chen Lihui, DensoADAS, mauropasse
-
-21.1.1 (2023-05-11)
--------------------
-* Fix race condition in events-executor (`#2177 <https://github.com/ros2/rclcpp/issues/2177>`_)
-* Add missing stdexcept include (`#2186 <https://github.com/ros2/rclcpp/issues/2186>`_)
-* Fix a format-security warning when building with clang (`#2171 <https://github.com/ros2/rclcpp/issues/2171>`_)
-* Fix delivered message kind (`#2175 <https://github.com/ros2/rclcpp/issues/2175>`_)
-* Contributors: Alberto Soragna, Chris Lalancette, methylDragon, Øystein Sture
-
-21.1.0 (2023-04-27)
--------------------
-
-21.0.0 (2023-04-18)
--------------------
-* Add support for logging service. (`#2122 <https://github.com/ros2/rclcpp/issues/2122>`_)
-* Picking ABI-incompatible executor changes (`#2170 <https://github.com/ros2/rclcpp/issues/2170>`_)
-* add events-executor and timers-manager in rclcpp (`#2155 <https://github.com/ros2/rclcpp/issues/2155>`_)
-* Create common structures for executors to use (`#2143 <https://github.com/ros2/rclcpp/issues/2143>`_)
-* Implement deliver message kind (`#2168 <https://github.com/ros2/rclcpp/issues/2168>`_)
-* Contributors: Alberto Soragna, Lei Liu, Michael Carroll, methylDragon
-
 20.0.0 (2023-04-13)
 -------------------
 * applied tracepoints for ring_buffer (`#2091 <https://github.com/ros2/rclcpp/issues/2091>`_)

rclcpp/include/rclcpp/any_service_callback.hpp

@@ -156,7 +156,7 @@ public:
     const std::shared_ptr<rmw_request_id_t> & request_header,
     std::shared_ptr<typename ServiceT::Request> request)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), false);
     if (std::holds_alternative<std::monostate>(callback_)) {
       // TODO(ivanpauno): Remove the set method, and force the users of this class
       // to pass a callback at construnciton.
@@ -182,7 +182,7 @@ public:
       const auto & cb = std::get<SharedPtrWithRequestHeaderCallback>(callback_);
       cb(request_header, std::move(request), response);
     }
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
     return response;
   }
 
@@ -191,9 +191,9 @@ public:
 #ifndef TRACETOOLS_DISABLED
     std::visit(
       [this](auto && arg) {
-        if (TRACETOOLS_TRACEPOINT_ENABLED(rclcpp_callback_register)) {
+        if (TRACEPOINT_ENABLED(rclcpp_callback_register)) {
           char * symbol = tracetools::get_symbol(arg);
-          TRACETOOLS_DO_TRACEPOINT(
+          DO_TRACEPOINT(
             rclcpp_callback_register,
             static_cast<const void *>(this),
             symbol);

rclcpp/include/rclcpp/any_subscription_callback.hpp

@@ -20,7 +20,7 @@
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
-#include <variant>
+#include <variant>  // NOLINT[build/include_order]
 
 #include "rosidl_runtime_cpp/traits.hpp"
 #include "tracetools/tracetools.h"
@@ -492,7 +492,7 @@ public:
     std::shared_ptr<ROSMessageType> message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), false);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -583,7 +583,7 @@ public:
           static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   // Dispatch when input is a serialized message and the output could be anything.
@@ -592,7 +592,7 @@ public:
     std::shared_ptr<rclcpp::SerializedMessage> serialized_message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), false);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), false);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -663,7 +663,7 @@ public:
           static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   void
@@ -671,7 +671,7 @@ public:
     std::shared_ptr<const SubscribedType> message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), true);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), true);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -793,7 +793,7 @@ public:
           static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   void
@@ -801,7 +801,7 @@ public:
     std::unique_ptr<SubscribedType, SubscribedTypeDeleter> message,
     const rclcpp::MessageInfo & message_info)
   {
-    TRACETOOLS_TRACEPOINT(callback_start, static_cast<const void *>(this), true);
+    TRACEPOINT(callback_start, static_cast<const void *>(this), true);
     // Check if the variant is "unset", throw if it is.
     if (callback_variant_.index() == 0) {
       if (std::get<0>(callback_variant_) == nullptr) {
@@ -927,7 +927,7 @@ public:
           static_assert(always_false_v<T>, "unhandled callback type");
         }
       }, callback_variant_);
-    TRACETOOLS_TRACEPOINT(callback_end, static_cast<const void *>(this));
+    TRACEPOINT(callback_end, static_cast<const void *>(this));
   }
 
   constexpr
@@ -965,9 +965,9 @@ public:
 #ifndef TRACETOOLS_DISABLED
     std::visit(
       [this](auto && callback) {
-        if (TRACETOOLS_TRACEPOINT_ENABLED(rclcpp_callback_register)) {
+        if (TRACEPOINT_ENABLED(rclcpp_callback_register)) {
           char * symbol = tracetools::get_symbol(callback);
-          TRACETOOLS_DO_TRACEPOINT(
+          DO_TRACEPOINT(
             rclcpp_callback_register,
             static_cast<const void *>(this),
             symbol);

rclcpp/include/rclcpp/client.hpp

@@ -20,13 +20,13 @@
 #include <future>
 #include <memory>
 #include <mutex>
-#include <optional>
+#include <optional>  // NOLINT, cpplint doesn't think this is a cpp std header
 #include <sstream>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 #include <utility>
-#include <variant>
+#include <variant>  // NOLINT
 #include <vector>
 
 #include "rcl/client.h"
@@ -363,16 +363,12 @@ protected:
   std::shared_ptr<rclcpp::Context> context_;
   rclcpp::Logger node_logger_;
 
-  std::recursive_mutex callback_mutex_;
-  // It is important to declare on_new_response_callback_ before
-  // client_handle_, so on destruction the client is
-  // destroyed first. Otherwise, the rmw client callback
-  // would point briefly to a destroyed function.
-  std::function<void(size_t)> on_new_response_callback_{nullptr};
-  // Declare client_handle_ after callback
   std::shared_ptr<rcl_client_t> client_handle_;
 
   std::atomic<bool> in_use_by_wait_set_{false};
+
+  std::recursive_mutex callback_mutex_;
+  std::function<void(size_t)> on_new_response_callback_{nullptr};
 };
 
 template<typename ServiceT>

rclcpp/include/rclcpp/context.hpp

@@ -26,7 +26,6 @@
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <stdexcept>
 
 #include "rcl/context.h"
 #include "rcl/guard_condition.h"

rclcpp/include/rclcpp/executors/executor_entities_collection.hpp

@@ -178,12 +178,6 @@ struct ExecutorEntitiesCollection
 
   /// Clear the entities collection
   void clear();
-
-  /// Remove entities that have expired weak ownership
-  /**
-   * \return The total number of removed entities
-   */
-  size_t remove_expired_entities();
 };
 
 /// Build an entities collection from callback groups

rclcpp/include/rclcpp/experimental/buffers/buffer_implementation_base.hpp

@@ -33,7 +33,6 @@ public:
 
   virtual void clear() = 0;
   virtual bool has_data() const = 0;
-  virtual size_t available_capacity() const = 0;
 };
 
 }  // namespace buffers

rclcpp/include/rclcpp/experimental/buffers/intra_process_buffer.hpp

@@ -44,7 +44,6 @@ public:
 
   virtual bool has_data() const = 0;
   virtual bool use_take_shared_method() const = 0;
-  virtual size_t available_capacity() const = 0;
 };
 
 template<
@@ -96,7 +95,7 @@ public:
 
     buffer_ = std::move(buffer_impl);
 
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_buffer_to_ipb,
       static_cast<const void *>(buffer_.get()),
       static_cast<const void *>(this));
@@ -144,11 +143,6 @@ public:
     return std::is_same<BufferT, MessageSharedPtr>::value;
   }
 
-  size_t available_capacity() const override
-  {
-    return buffer_->available_capacity();
-  }
-
 private:
   std::unique_ptr<BufferImplementationBase<BufferT>> buffer_;
 

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

@@ -52,10 +52,7 @@ public:
     if (capacity == 0) {
       throw std::invalid_argument("capacity must be a positive, non-zero value");
     }
-    TRACETOOLS_TRACEPOINT(
-      rclcpp_construct_ring_buffer,
-      static_cast<const void *>(this),
-      capacity_);
+    TRACEPOINT(rclcpp_construct_ring_buffer, static_cast<const void *>(this), capacity_);
   }
 
   virtual ~RingBufferImplementation() {}
@@ -72,7 +69,7 @@ public:
 
     write_index_ = next_(write_index_);
     ring_buffer_[write_index_] = std::move(request);
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_ring_buffer_enqueue,
       static_cast<const void *>(this),
       write_index_,
@@ -101,7 +98,7 @@ public:
     }
 
     auto request = std::move(ring_buffer_[read_index_]);
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_ring_buffer_dequeue,
       static_cast<const void *>(this),
       read_index_,
@@ -151,21 +148,9 @@ public:
     return is_full_();
   }
 
-  /// Get the remaining capacity to store messages
-  /**
-   * This member function is thread-safe.
-   *
-   * \return the number of free capacity for new messages
-   */
-  size_t available_capacity() const
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    return available_capacity_();
-  }
-
   void clear()
   {
-    TRACETOOLS_TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
+    TRACEPOINT(rclcpp_ring_buffer_clear, static_cast<const void *>(this));
   }
 
 private:
@@ -204,17 +189,6 @@ private:
     return size_ == capacity_;
   }
 
-  /// Get the remaining capacity to store messages
-  /**
-   * This member function is not thread-safe.
-   *
-   * \return the number of free capacity for new messages
-   */
-  inline size_t available_capacity_() const
-  {
-    return capacity_ - size_;
-  }
-
   size_t capacity_;
 
   std::vector<BufferT> ring_buffer_;

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

@@ -243,11 +243,6 @@ private:
   std::function<void(size_t, int)>
   create_waitable_callback(const rclcpp::Waitable * waitable_id);
 
-  /// Utility to add the notify waitable to an entities collection
-  void
-  add_notify_waitable_to_collection(
-    rclcpp::executors::ExecutorEntitiesCollection::WaitableCollection & collection);
-
   /// Searches for the provided entity_id in the collection and returns the entity if valid
   template<typename CollectionType>
   typename CollectionType::EntitySharedPtr
@@ -274,11 +269,8 @@ private:
   rclcpp::experimental::executors::EventsQueue::UniquePtr events_queue_;
 
   std::shared_ptr<rclcpp::executors::ExecutorEntitiesCollector> entities_collector_;
-  std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> notify_waitable_;
-
-  /// Mutex to protect the current_entities_collection_
-  std::recursive_mutex collection_mutex_;
   std::shared_ptr<rclcpp::executors::ExecutorEntitiesCollection> current_entities_collection_;
+  std::shared_ptr<rclcpp::executors::ExecutorNotifyWaitable> notify_waitable_;
 
   /// Flag used to reduce the number of unnecessary waitable events
   std::atomic<bool> notify_waitable_event_pushed_ {false};

rclcpp/include/rclcpp/experimental/intra_process_manager.hpp

@@ -306,11 +306,6 @@ public:
   rclcpp::experimental::SubscriptionIntraProcessBase::SharedPtr
   get_subscription_intra_process(uint64_t intra_process_subscription_id);
 
-  /// Return the lowest available capacity for all subscription buffers for a publisher id.
-  RCLCPP_PUBLIC
-  size_t
-  lowest_available_capacity(const uint64_t intra_process_publisher_id) const;
-
 private:
   struct SplittedSubscriptions
   {

rclcpp/include/rclcpp/experimental/subscription_intra_process.hpp

@@ -87,7 +87,7 @@ public:
       buffer_type),
     any_callback_(callback)
   {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_subscription_callback_added,
       static_cast<const void *>(this),
       static_cast<const void *>(&any_callback_));

rclcpp/include/rclcpp/experimental/subscription_intra_process_base.hpp

@@ -62,11 +62,6 @@ public:
   void
   add_to_wait_set(rcl_wait_set_t * wait_set) override;
 
-  RCLCPP_PUBLIC
-  virtual
-  size_t
-  available_capacity() const = 0;
-
   bool
   is_ready(rcl_wait_set_t * wait_set) override = 0;
 

rclcpp/include/rclcpp/experimental/subscription_intra_process_buffer.hpp

@@ -93,7 +93,7 @@ public:
       buffer_type,
       qos_profile,
       std::make_shared<Alloc>(subscribed_type_allocator_));
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_ipb_to_subscription,
       static_cast<const void *>(buffer_.get()),
       static_cast<const void *>(this));
@@ -169,11 +169,6 @@ public:
     return buffer_->use_take_shared_method();
   }
 
-  size_t available_capacity() const override
-  {
-    return buffer_->available_capacity();
-  }
-
 protected:
   void
   trigger_guard_condition() override

rclcpp/include/rclcpp/node_interfaces/node_logging.hpp

@@ -23,9 +23,6 @@
 #include "rclcpp/node_interfaces/node_logging_interface.hpp"
 #include "rclcpp/visibility_control.hpp"
 
-#include "rcl_interfaces/srv/get_logger_levels.hpp"
-#include "rcl_interfaces/srv/set_logger_levels.hpp"
-
 namespace rclcpp
 {
 namespace node_interfaces
@@ -38,7 +35,7 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeLoggingInterface)
 
   RCLCPP_PUBLIC
-  explicit NodeLogging(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base);
+  explicit NodeLogging(rclcpp::node_interfaces::NodeBaseInterface * node_base);
 
   RCLCPP_PUBLIC
   virtual
@@ -52,21 +49,13 @@ public:
   const char *
   get_logger_name() const override;
 
-  RCLCPP_PUBLIC
-  void
-  create_logger_services(
-    node_interfaces::NodeServicesInterface::SharedPtr node_services) override;
-
 private:
   RCLCPP_DISABLE_COPY(NodeLogging)
 
   /// Handle to the NodeBaseInterface given in the constructor.
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base_;
+  rclcpp::node_interfaces::NodeBaseInterface * node_base_;
 
   rclcpp::Logger logger_;
-
-  rclcpp::Service<rcl_interfaces::srv::GetLoggerLevels>::SharedPtr get_loggers_service_;
-  rclcpp::Service<rcl_interfaces::srv::SetLoggerLevels>::SharedPtr set_loggers_service_;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_logging_interface.hpp

@@ -19,7 +19,6 @@
 
 #include "rclcpp/logger.hpp"
 #include "rclcpp/macros.hpp"
-#include "rclcpp/node_interfaces/node_services_interface.hpp"
 #include "rclcpp/node_interfaces/detail/node_interfaces_helpers.hpp"
 #include "rclcpp/visibility_control.hpp"
 
@@ -55,13 +54,6 @@ public:
   virtual
   const char *
   get_logger_name() const = 0;
-
-  /// create logger services
-  RCLCPP_PUBLIC
-  virtual
-  void
-  create_logger_services(
-    node_interfaces::NodeServicesInterface::SharedPtr node_services) = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_options.hpp

@@ -50,7 +50,6 @@ public:
    *   - clock_type = RCL_ROS_TIME
    *   - clock_qos = rclcpp::ClockQoS()
    *   - use_clock_thread = true
-   *   - enable_logger_service = false
    *   - rosout_qos = rclcpp::RosoutQoS()
    *   - parameter_event_qos = rclcpp::ParameterEventQoS
    *     - with history setting and depth from rmw_qos_profile_parameter_events
@@ -233,24 +232,6 @@ public:
   NodeOptions &
   start_parameter_services(bool start_parameter_services);
 
-  /// Return the enable_logger_service flag.
-  RCLCPP_PUBLIC
-  bool
-  enable_logger_service() const;
-
-  /// Set the enable_logger_service flag, return this for logger idiom.
-  /**
-   * If true, ROS services are created to allow external nodes to get
-   * and set logger levels of this node.
-   *
-   * If false, loggers will still be configured and set logger levels locally,
-   * but logger levels cannot be changed remotely .
-   *
-   */
-  RCLCPP_PUBLIC
-  NodeOptions &
-  enable_logger_service(bool enable_log_service);
-
   /// Return the start_parameter_event_publisher flag.
   RCLCPP_PUBLIC
   bool
@@ -440,8 +421,6 @@ private:
 
   bool use_clock_thread_ {true};
 
-  bool enable_logger_service_ {false};
-
   rclcpp::QoS parameter_event_qos_ = rclcpp::ParameterEventsQoS(
     rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)
   );

rclcpp/include/rclcpp/publisher.hpp

@@ -421,7 +421,7 @@ protected:
   void
   do_inter_process_publish(const ROSMessageType & msg)
   {
-    TRACETOOLS_TRACEPOINT(rclcpp_publish, nullptr, static_cast<const void *>(&msg));
+    TRACEPOINT(rclcpp_publish, nullptr, static_cast<const void *>(&msg));
     auto status = rcl_publish(publisher_handle_.get(), &msg, nullptr);
 
     if (RCL_RET_PUBLISHER_INVALID == status) {
@@ -484,7 +484,7 @@ protected:
     if (!msg) {
       throw std::runtime_error("cannot publish msg which is a null pointer");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_intra_publish,
       static_cast<const void *>(publisher_handle_.get()),
       msg.get());
@@ -506,7 +506,7 @@ protected:
     if (!msg) {
       throw std::runtime_error("cannot publish msg which is a null pointer");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_intra_publish,
       static_cast<const void *>(publisher_handle_.get()),
       msg.get());
@@ -529,7 +529,7 @@ protected:
     if (!msg) {
       throw std::runtime_error("cannot publish msg which is a null pointer");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_intra_publish,
       static_cast<const void *>(publisher_handle_.get()),
       msg.get());

rclcpp/include/rclcpp/publisher_base.hpp

@@ -215,17 +215,6 @@ public:
   std::vector<rclcpp::NetworkFlowEndpoint>
   get_network_flow_endpoints() const;
 
-  /// Return the lowest available capacity for all subscription buffers.
-  /**
-   * For intraprocess communication return the lowest buffer capacity for all subscriptions.
-   * If intraprocess is disabled or no intraprocess subscriptions present, return maximum of size_t.
-   * On failure return 0.
-   * \return lowest buffer capacity for all subscriptions
-   */
-  RCLCPP_PUBLIC
-  size_t
-  lowest_available_ipm_capacity() const;
-
   /// Wait until all published messages are acknowledged or until the specified timeout elapses.
   /**
    * This method waits until all published messages are acknowledged by all matching

rclcpp/include/rclcpp/service.hpp

@@ -265,19 +265,15 @@ protected:
 
   std::shared_ptr<rcl_node_t> node_handle_;
 
-  std::recursive_mutex callback_mutex_;
-  // It is important to declare on_new_request_callback_ before
-  // service_handle_, so on destruction the service is
-  // destroyed first. Otherwise, the rmw service callback
-  // would point briefly to a destroyed function.
-  std::function<void(size_t)> on_new_request_callback_{nullptr};
-  // Declare service_handle_ after callback
   std::shared_ptr<rcl_service_t> service_handle_;
   bool owns_rcl_handle_ = true;
 
   rclcpp::Logger node_logger_;
 
   std::atomic<bool> in_use_by_wait_set_{false};
+
+  std::recursive_mutex callback_mutex_;
+  std::function<void(size_t)> on_new_request_callback_{nullptr};
 };
 
 template<typename ServiceT>
@@ -352,7 +348,7 @@ public:
 
       rclcpp::exceptions::throw_from_rcl_error(ret, "could not create service");
     }
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_service_callback_added,
       static_cast<const void *>(get_service_handle().get()),
       static_cast<const void *>(&any_callback_));
@@ -387,7 +383,7 @@ public:
     }
 
     service_handle_ = service_handle;
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_service_callback_added,
       static_cast<const void *>(get_service_handle().get()),
       static_cast<const void *>(&any_callback_));
@@ -424,7 +420,7 @@ public:
     // In this case, rcl owns the service handle memory
     service_handle_ = std::shared_ptr<rcl_service_t>(new rcl_service_t);
     service_handle_->impl = service_handle->impl;
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_service_callback_added,
       static_cast<const void *>(get_service_handle().get()),
       static_cast<const void *>(&any_callback_));

rclcpp/include/rclcpp/subscription.hpp

@@ -185,7 +185,7 @@ public:
         this->get_topic_name(),  // important to get like this, as it has the fully-qualified name
         qos_profile,
         resolve_intra_process_buffer_type(options_.intra_process_buffer_type, callback));
-      TRACETOOLS_TRACEPOINT(
+      TRACEPOINT(
         rclcpp_subscription_init,
         static_cast<const void *>(get_subscription_handle().get()),
         static_cast<const void *>(subscription_intra_process_.get()));
@@ -201,11 +201,11 @@ public:
       this->subscription_topic_statistics_ = std::move(subscription_topic_statistics);
     }
 
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_subscription_init,
       static_cast<const void *>(get_subscription_handle().get()),
       static_cast<const void *>(this));
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_subscription_callback_added,
       static_cast<const void *>(this),
       static_cast<const void *>(&any_callback_));

rclcpp/include/rclcpp/subscription_base.hpp

@@ -260,13 +260,13 @@ public:
   bool
   is_serialized() const;
 
-  /// Return the delivered message kind.
+  /// Return the type of the subscription.
   /**
    * \return `DeliveredMessageKind`, which adjusts how messages are received and delivered.
    */
   RCLCPP_PUBLIC
   DeliveredMessageKind
-  get_delivered_message_kind() const;
+  get_subscription_type() const;
 
   /// Get matching publisher count.
   /** \return The number of publishers on this topic. */
@@ -645,14 +645,6 @@ protected:
   rclcpp::node_interfaces::NodeBaseInterface * const node_base_;
 
   std::shared_ptr<rcl_node_t> node_handle_;
-
-  std::recursive_mutex callback_mutex_;
-  // It is important to declare on_new_message_callback_ before
-  // subscription_handle_, so on destruction the subscription is
-  // destroyed first. Otherwise, the rmw subscription callback
-  // would point briefly to a destroyed function.
-  std::function<void(size_t)> on_new_message_callback_{nullptr};
-  // Declare subscription_handle_ after callback
   std::shared_ptr<rcl_subscription_t> subscription_handle_;
   std::shared_ptr<rcl_subscription_t> intra_process_subscription_handle_;
   rclcpp::Logger node_logger_;
@@ -671,12 +663,15 @@ private:
   RCLCPP_DISABLE_COPY(SubscriptionBase)
 
   rosidl_message_type_support_t type_support_;
-  DeliveredMessageKind delivered_message_kind_;
+  DeliveredMessageKind delivered_message_type_;
 
   std::atomic<bool> subscription_in_use_by_wait_set_{false};
   std::atomic<bool> intra_process_subscription_waitable_in_use_by_wait_set_{false};
   std::unordered_map<rclcpp::EventHandlerBase *,
     std::atomic<bool>> qos_events_in_use_by_wait_set_;
+
+  std::recursive_mutex callback_mutex_;
+  std::function<void(size_t)> on_new_message_callback_{nullptr};
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/timer.hpp

@@ -223,14 +223,14 @@ public:
   )
   : TimerBase(clock, period, context), callback_(std::forward<FunctorT>(callback))
   {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_timer_callback_added,
       static_cast<const void *>(get_timer_handle().get()),
       reinterpret_cast<const void *>(&callback_));
 #ifndef TRACETOOLS_DISABLED
-    if (TRACETOOLS_TRACEPOINT_ENABLED(rclcpp_callback_register)) {
+    if (TRACEPOINT_ENABLED(rclcpp_callback_register)) {
       char * symbol = tracetools::get_symbol(callback_);
-      TRACETOOLS_DO_TRACEPOINT(
+      DO_TRACEPOINT(
         rclcpp_callback_register,
         reinterpret_cast<const void *>(&callback_),
         symbol);
@@ -269,9 +269,9 @@ public:
   void
   execute_callback() override
   {
-    TRACETOOLS_TRACEPOINT(callback_start, reinterpret_cast<const void *>(&callback_), false);
+    TRACEPOINT(callback_start, reinterpret_cast<const void *>(&callback_), false);
     execute_callback_delegate<>();
-    TRACETOOLS_TRACEPOINT(callback_end, reinterpret_cast<const void *>(&callback_));
+    TRACEPOINT(callback_end, reinterpret_cast<const void *>(&callback_));
   }
 
   // void specialization

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>21.2.0</version>
+  <version>20.0.0</version>
   <description>The ROS client library in C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp/src/rclcpp/executor.cpp

@@ -42,13 +42,12 @@
 using namespace std::chrono_literals;
 
 using rclcpp::Executor;
+class rclcpp::ExecutorImplementation {};
 
 /// Mask to indicate to the waitset to only add the subscription.
 /// The events and intraprocess waitable are already added via the callback group.
 static constexpr rclcpp::SubscriptionWaitSetMask kDefaultSubscriptionMask = {true, false, false};
 
-class rclcpp::ExecutorImplementation {};
-
 Executor::Executor(const rclcpp::ExecutorOptions & options)
 : spinning(false),
   interrupt_guard_condition_(std::make_shared<rclcpp::GuardCondition>(options.context)),
@@ -83,31 +82,46 @@ Executor::~Executor()
 
   notify_waitable_->remove_guard_condition(interrupt_guard_condition_);
   notify_waitable_->remove_guard_condition(shutdown_guard_condition_);
+
+  std::cout << "Executor::~Executor" << std::endl;
+
   current_collection_.timers.update(
     {}, {},
-    [this](auto timer) {wait_set_.remove_timer(timer);});
+    [this](auto timer) {
+      std::cout << "remove_timer(" << timer.get() << ")" << std::endl;
+      wait_set_.remove_timer(timer);
+    });
 
   current_collection_.subscriptions.update(
     {}, {},
     [this](auto subscription) {
+      std::cout << "remove_subscription(" << subscription.get() << ")" << std::endl;
       wait_set_.remove_subscription(subscription, kDefaultSubscriptionMask);
     });
 
   current_collection_.clients.update(
     {}, {},
-    [this](auto client) {wait_set_.remove_client(client);});
+    [this](auto client) {
+      std::cout << "remove_client(" << client.get() << ")" << std::endl;
+      wait_set_.remove_client(client);});
 
   current_collection_.services.update(
     {}, {},
-    [this](auto service) {wait_set_.remove_service(service);});
+    [this](auto service) {
+      std::cout << "remove_service(" << service.get() << ")" << std::endl;
+      wait_set_.remove_service(service);});
 
   current_collection_.guard_conditions.update(
     {}, {},
-    [this](auto guard_condition) {wait_set_.remove_guard_condition(guard_condition);});
+    [this](auto guard_condition) {
+      std::cout << "remove_guard_condition(" << guard_condition.get() << ")" << std::endl;
+        wait_set_.remove_guard_condition(guard_condition);});
 
   current_collection_.waitables.update(
     {}, {},
-    [this](auto waitable) {wait_set_.remove_waitable(waitable);});
+    [this](auto waitable) {
+      std::cout << "remove_waitable(" << waitable.get() << ")" << std::endl;
+      wait_set_.remove_waitable(waitable);});
 
   // Remove shutdown callback handle registered to Context
   if (!context_->remove_on_shutdown_callback(shutdown_callback_handle_)) {
@@ -378,13 +392,13 @@ Executor::execute_any_executable(AnyExecutable & any_exec)
   }
 
   if (any_exec.timer) {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_executor_execute,
       static_cast<const void *>(any_exec.timer->get_timer_handle().get()));
     execute_timer(any_exec.timer);
   }
   if (any_exec.subscription) {
-    TRACETOOLS_TRACEPOINT(
+    TRACEPOINT(
       rclcpp_executor_execute,
       static_cast<const void *>(any_exec.subscription->get_subscription_handle().get()));
     execute_subscription(any_exec.subscription);
@@ -450,7 +464,7 @@ Executor::execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)
   rclcpp::MessageInfo message_info;
   message_info.get_rmw_message_info().from_intra_process = false;
 
-  switch (subscription->get_delivered_message_kind()) {
+  switch (subscription->get_subscription_type()) {
     // Deliver ROS message
     case rclcpp::DeliveredMessageKind::ROS_MESSAGE:
       {
@@ -590,19 +604,29 @@ Executor::collect_entities()
     collection.waitables.insert({notify_waitable.get(), {notify_waitable, {}}});
   }
 
+  std::cout << "current_collection.timers: " << current_collection_.timers.size() << std::endl;
+  std::cout << "next_collection.timers: " << collection.timers.size() << std::endl;
   // Update each of the groups of entities in the current collection, adding or removing
   // from the wait set as necessary.
   current_collection_.timers.update(
     collection.timers,
-    [this](auto timer) {wait_set_.add_timer(timer);},
-    [this](auto timer) {wait_set_.remove_timer(timer);});
+    [this](auto timer) {
+        std::cout << "add_timer(" << timer << ")" << std::endl;
+        wait_set_.add_timer(timer);},
+    [this](auto timer) {
+        std::cout << "remove_timer(" << timer << ")" << std::endl;
+        wait_set_.remove_timer(timer);});
 
+  std::cout << "current_collection.subscriptions: " << current_collection_.subscriptions.size() << std::endl;
+  std::cout << "next_collection.subscriptions: " << collection.subscriptions.size() << std::endl;
   current_collection_.subscriptions.update(
     collection.subscriptions,
     [this](auto subscription) {
+      std::cout << "add_subscription(" << subscription << ")" << std::endl;
       wait_set_.add_subscription(subscription, kDefaultSubscriptionMask);
     },
     [this](auto subscription) {
+      std::cout << "remove_subscription(" << subscription << ")" << std::endl;
       wait_set_.remove_subscription(subscription, kDefaultSubscriptionMask);
     });
 
@@ -628,21 +652,17 @@ Executor::collect_entities()
     },
     [this](auto waitable) {wait_set_.remove_waitable(waitable);});
 
-  // In the case that an entity already has an expired weak pointer
-  // before being removed from the waitset, additionally prune the waitset.
-  this->wait_set_.prune_deleted_entities();
   this->entities_need_rebuild_.store(false);
 }
 
 void
 Executor::wait_for_work(std::chrono::nanoseconds timeout)
 {
-  TRACETOOLS_TRACEPOINT(rclcpp_executor_wait_for_work, timeout.count());
-  {
-    std::lock_guard<std::mutex> guard(mutex_);
-    if (current_collection_.empty() || this->entities_need_rebuild_.load()) {
-      this->collect_entities();
-    }
+  TRACEPOINT(rclcpp_executor_wait_for_work, timeout.count());
+
+  std::lock_guard<std::mutex> guard(mutex_);
+  if (current_collection_.empty() || this->entities_need_rebuild_.load()) {
+    this->collect_entities();
   }
 
   auto wait_result = wait_set_.wait(timeout);
@@ -657,7 +677,7 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
 bool
 Executor::get_next_ready_executable(AnyExecutable & any_executable)
 {
-  TRACETOOLS_TRACEPOINT(rclcpp_executor_get_next_ready);
+  TRACEPOINT(rclcpp_executor_get_next_ready);
 
   std::lock_guard<std::mutex> guard(mutex_);
   if (ready_executables_.size() == 0) {

rclcpp/src/rclcpp/executors/executor_entities_collection.cpp

@@ -39,30 +39,6 @@ void ExecutorEntitiesCollection::clear()
   waitables.clear();
 }
 
-size_t ExecutorEntitiesCollection::remove_expired_entities()
-{
-  auto remove_entities = [](auto & collection) -> size_t {
-      size_t removed = 0;
-      for (auto it = collection.begin(); it != collection.end(); ) {
-        if (it->second.entity.expired()) {
-          ++removed;
-          it = collection.erase(it);
-        } else {
-          ++it;
-        }
-      }
-      return removed;
-    };
-
-  return
-    remove_entities(subscriptions) +
-    remove_entities(timers) +
-    remove_entities(guard_conditions) +
-    remove_entities(clients) +
-    remove_entities(services) +
-    remove_entities(waitables);
-}
-
 void
 build_entities_collection(
   const std::vector<rclcpp::CallbackGroup::WeakPtr> & callback_groups,

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

@@ -50,9 +50,6 @@ EventsExecutor::EventsExecutor(
   timers_manager_ =
     std::make_shared<rclcpp::experimental::TimersManager>(context_, timer_on_ready_cb);
 
-  this->current_entities_collection_ =
-    std::make_shared<rclcpp::executors::ExecutorEntitiesCollection>();
-
   notify_waitable_ = std::make_shared<rclcpp::executors::ExecutorNotifyWaitable>(
     [this]() {
       // This callback is invoked when:
@@ -64,10 +61,6 @@ EventsExecutor::EventsExecutor(
       this->refresh_current_collection_from_callback_groups();
     });
 
-  // Make sure that the notify waitable is immediately added to the collection
-  // to avoid missing events
-  this->add_notify_waitable_to_collection(current_entities_collection_->waitables);
-
   notify_waitable_->add_guard_condition(interrupt_guard_condition_);
   notify_waitable_->add_guard_condition(shutdown_guard_condition_);
 
@@ -94,6 +87,9 @@ EventsExecutor::EventsExecutor(
 
   this->entities_collector_ =
     std::make_shared<rclcpp::executors::ExecutorEntitiesCollector>(notify_waitable_);
+
+  this->current_entities_collection_ =
+    std::make_shared<rclcpp::executors::ExecutorEntitiesCollection>();
 }
 
 EventsExecutor::~EventsExecutor()
@@ -273,13 +269,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
   switch (event.type) {
     case ExecutorEventType::CLIENT_EVENT:
       {
-        rclcpp::ClientBase::SharedPtr client;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          client = this->retrieve_entity(
-            static_cast<const rcl_client_t *>(event.entity_key),
-            current_entities_collection_->clients);
-        }
+        auto client = this->retrieve_entity(
+          static_cast<const rcl_client_t *>(event.entity_key),
+          current_entities_collection_->clients);
+
         if (client) {
           for (size_t i = 0; i < event.num_events; i++) {
             execute_client(client);
@@ -290,13 +283,9 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       }
     case ExecutorEventType::SUBSCRIPTION_EVENT:
       {
-        rclcpp::SubscriptionBase::SharedPtr subscription;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          subscription = this->retrieve_entity(
-            static_cast<const rcl_subscription_t *>(event.entity_key),
-            current_entities_collection_->subscriptions);
-        }
+        auto subscription = this->retrieve_entity(
+          static_cast<const rcl_subscription_t *>(event.entity_key),
+          current_entities_collection_->subscriptions);
         if (subscription) {
           for (size_t i = 0; i < event.num_events; i++) {
             execute_subscription(subscription);
@@ -306,13 +295,10 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       }
     case ExecutorEventType::SERVICE_EVENT:
       {
-        rclcpp::ServiceBase::SharedPtr service;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          service = this->retrieve_entity(
-            static_cast<const rcl_service_t *>(event.entity_key),
-            current_entities_collection_->services);
-        }
+        auto service = this->retrieve_entity(
+          static_cast<const rcl_service_t *>(event.entity_key),
+          current_entities_collection_->services);
+
         if (service) {
           for (size_t i = 0; i < event.num_events; i++) {
             execute_service(service);
@@ -329,13 +315,9 @@ EventsExecutor::execute_event(const ExecutorEvent & event)
       }
     case ExecutorEventType::WAITABLE_EVENT:
       {
-        rclcpp::Waitable::SharedPtr waitable;
-        {
-          std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-          waitable = this->retrieve_entity(
-            static_cast<const rclcpp::Waitable *>(event.entity_key),
-            current_entities_collection_->waitables);
-        }
+        auto waitable = this->retrieve_entity(
+          static_cast<const rclcpp::Waitable *>(event.entity_key),
+          current_entities_collection_->waitables);
         if (waitable) {
           for (size_t i = 0; i < event.num_events; i++) {
             auto data = waitable->take_data_by_entity_id(event.waitable_data);
@@ -400,7 +382,6 @@ EventsExecutor::get_automatically_added_callback_groups_from_nodes()
 void
 EventsExecutor::refresh_current_collection_from_callback_groups()
 {
-  // Build the new collection
   this->entities_collector_->update_collections();
   auto callback_groups = this->entities_collector_->get_all_callback_groups();
   rclcpp::executors::ExecutorEntitiesCollection new_collection;
@@ -414,11 +395,18 @@ EventsExecutor::refresh_current_collection_from_callback_groups()
   // retrieved in the "standard" way.
   // To do it, we need to add the notify waitable as an entry in both the new and
   // current collections such that it's neither added or removed.
-  this->add_notify_waitable_to_collection(new_collection.waitables);
+  rclcpp::CallbackGroup::WeakPtr weak_group_ptr;
+  new_collection.waitables.insert(
+  {
+    this->notify_waitable_.get(),
+    {this->notify_waitable_, weak_group_ptr}
+  });
 
-  // Acquire lock before modifying the current collection
-  std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-  this->add_notify_waitable_to_collection(current_entities_collection_->waitables);
+  this->current_entities_collection_->waitables.insert(
+  {
+    this->notify_waitable_.get(),
+    {this->notify_waitable_, weak_group_ptr}
+  });
 
   this->refresh_current_collection(new_collection);
 }
@@ -427,9 +415,6 @@ void
 EventsExecutor::refresh_current_collection(
   const rclcpp::executors::ExecutorEntitiesCollection & new_collection)
 {
-  // Acquire lock before modifying the current collection
-  std::lock_guard<std::recursive_mutex> lock(collection_mutex_);
-
   current_entities_collection_->timers.update(
     new_collection.timers,
     [this](rclcpp::TimerBase::SharedPtr timer) {timers_manager_->add_timer(timer);},
@@ -501,16 +486,3 @@ EventsExecutor::create_waitable_callback(const rclcpp::Waitable * entity_key)
     };
   return callback;
 }
-
-void
-EventsExecutor::add_notify_waitable_to_collection(
-  rclcpp::executors::ExecutorEntitiesCollection::WaitableCollection & collection)
-{
-  // The notify waitable is not associated to any group, so use an invalid one
-  rclcpp::CallbackGroup::WeakPtr weak_group_ptr;
-  collection.insert(
-  {
-    this->notify_waitable_.get(),
-    {this->notify_waitable_, weak_group_ptr}
-  });
-}

rclcpp/src/rclcpp/intra_process_manager.cpp

@@ -225,52 +225,5 @@ IntraProcessManager::can_communicate(
   return true;
 }
 
-size_t
-IntraProcessManager::lowest_available_capacity(const uint64_t intra_process_publisher_id) const
-{
-  size_t capacity = std::numeric_limits<size_t>::max();
-
-  auto publisher_it = pub_to_subs_.find(intra_process_publisher_id);
-  if (publisher_it == pub_to_subs_.end()) {
-    // Publisher is either invalid or no longer exists.
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Calling lowest_available_capacity for invalid or no longer existing publisher id");
-    return 0u;
-  }
-
-  if (publisher_it->second.take_shared_subscriptions.empty() &&
-    publisher_it->second.take_ownership_subscriptions.empty())
-  {
-    // no subscriptions available
-    return 0u;
-  }
-
-  auto available_capacity = [this, &capacity](const uint64_t intra_process_subscription_id)
-    {
-      auto subscription_it = subscriptions_.find(intra_process_subscription_id);
-      if (subscription_it != subscriptions_.end()) {
-        auto subscription = subscription_it->second.lock();
-        if (subscription) {
-          capacity = std::min(capacity, subscription->available_capacity());
-        }
-      } else {
-        // Subscription is either invalid or no longer exists.
-        RCLCPP_WARN(
-          rclcpp::get_logger("rclcpp"),
-          "Calling available_capacity for invalid or no longer existing subscription id");
-      }
-    };
-
-  for (const auto sub_id : publisher_it->second.take_shared_subscriptions) {
-    available_capacity(sub_id);
-  }
-
-  for (const auto sub_id : publisher_it->second.take_ownership_subscriptions) {
-    available_capacity(sub_id);
-  }
-
-  return capacity;
-}
 }  // namespace experimental
 }  // namespace rclcpp

rclcpp/src/rclcpp/logging_mutex.cpp

@@ -14,7 +14,6 @@
 
 #include <memory>
 #include <mutex>
-#include <stdexcept>
 
 #include "rcutils/macros.h"
 

rclcpp/src/rclcpp/node.cpp

@@ -167,7 +167,7 @@ Node::Node(
       options.use_intra_process_comms(),
       options.enable_topic_statistics())),
   node_graph_(new rclcpp::node_interfaces::NodeGraph(node_base_.get())),
-  node_logging_(new rclcpp::node_interfaces::NodeLogging(node_base_)),
+  node_logging_(new rclcpp::node_interfaces::NodeLogging(node_base_.get())),
   node_timers_(new rclcpp::node_interfaces::NodeTimers(node_base_.get())),
   node_topics_(new rclcpp::node_interfaces::NodeTopics(node_base_.get(), node_timers_.get())),
   node_services_(new rclcpp::node_interfaces::NodeServices(node_base_.get())),
@@ -225,10 +225,6 @@ Node::Node(
     node_topics_->resolve_topic_name("/parameter_events"),
     options.parameter_event_qos(),
     rclcpp::detail::PublisherQosParametersTraits{});
-
-  if (options.enable_logger_service()) {
-    node_logging_->create_logger_services(node_services_);
-  }
 }
 
 Node::Node(

rclcpp/src/rclcpp/node_interfaces/node_logging.cpp

@@ -12,13 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "rclcpp/node_impl.hpp"
 #include "rclcpp/node_interfaces/node_logging.hpp"
-#include "rclcpp/node_interfaces/node_services_interface.hpp"
 
 using rclcpp::node_interfaces::NodeLogging;
 
-NodeLogging::NodeLogging(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base)
+NodeLogging::NodeLogging(rclcpp::node_interfaces::NodeBaseInterface * node_base)
 : node_base_(node_base)
 {
   logger_ = rclcpp::get_logger(NodeLogging::get_logger_name());
@@ -39,55 +37,3 @@ NodeLogging::get_logger_name() const
 {
   return rcl_node_get_logger_name(node_base_->get_rcl_node_handle());
 }
-
-void NodeLogging::create_logger_services(
-  node_interfaces::NodeServicesInterface::SharedPtr node_services)
-{
-  rclcpp::ServicesQoS qos_profile;
-  const std::string node_name = node_base_->get_name();
-  auto callback_group = node_base_->get_default_callback_group();
-
-  get_loggers_service_ = rclcpp::create_service<rcl_interfaces::srv::GetLoggerLevels>(
-    node_base_, node_services,
-    node_name + "/get_logger_levels",
-    [](
-      const std::shared_ptr<rmw_request_id_t>,
-      const std::shared_ptr<rcl_interfaces::srv::GetLoggerLevels::Request> request,
-      std::shared_ptr<rcl_interfaces::srv::GetLoggerLevels::Response> response)
-    {
-      for (auto & name : request->names) {
-        rcl_interfaces::msg::LoggerLevel logger_level;
-        logger_level.name = name;
-        auto ret = rcutils_logging_get_logger_level(name.c_str());
-        if (ret < 0) {
-          logger_level.level = 0;
-        } else {
-          logger_level.level = static_cast<uint8_t>(ret);
-        }
-        response->levels.push_back(std::move(logger_level));
-      }
-    },
-    qos_profile, callback_group);
-
-  set_loggers_service_ = rclcpp::create_service<rcl_interfaces::srv::SetLoggerLevels>(
-    node_base_, node_services,
-    node_name + "/set_logger_levels",
-    [](
-      const std::shared_ptr<rmw_request_id_t>,
-      const std::shared_ptr<rcl_interfaces::srv::SetLoggerLevels::Request> request,
-      std::shared_ptr<rcl_interfaces::srv::SetLoggerLevels::Response> response)
-    {
-      rcl_interfaces::msg::SetLoggerLevelsResult result;
-      for (auto & level : request->levels) {
-        auto ret = rcutils_logging_set_logger_level(level.name.c_str(), level.level);
-        if (ret != RCUTILS_RET_OK) {
-          result.successful = false;
-          result.reason = rcutils_get_error_string().str;
-        } else {
-          result.successful = true;
-        }
-        response->results.push_back(std::move(result));
-      }
-    },
-    qos_profile, callback_group);
-}

rclcpp/src/rclcpp/node_interfaces/node_timers.cpp

@@ -50,7 +50,7 @@ NodeTimers::add_timer(
             std::string("failed to notify wait set on timer creation: ") + ex.what());
   }
 
-  TRACETOOLS_TRACEPOINT(
+  TRACEPOINT(
     rclcpp_timer_link_node,
     static_cast<const void *>(timer->get_timer_handle().get()),
     static_cast<const void *>(node_base_->get_rcl_node_handle()));

rclcpp/src/rclcpp/node_options.cpp

@@ -248,19 +248,6 @@ NodeOptions::start_parameter_services(bool start_parameter_services)
   return *this;
 }
 
-bool
-NodeOptions::enable_logger_service() const
-{
-  return this->enable_logger_service_;
-}
-
-NodeOptions &
-NodeOptions::enable_logger_service(bool enable_logger_service)
-{
-  this->enable_logger_service_ = enable_logger_service;
-  return *this;
-}
-
 bool
 NodeOptions::start_parameter_event_publisher() const
 {

rclcpp/src/rclcpp/publisher_base.cpp

@@ -384,22 +384,3 @@ std::vector<rclcpp::NetworkFlowEndpoint> PublisherBase::get_network_flow_endpoin
 
   return network_flow_endpoint_vector;
 }
-
-size_t PublisherBase::lowest_available_ipm_capacity() const
-{
-  if (!intra_process_is_enabled_) {
-    return 0u;
-  }
-
-  auto ipm = weak_ipm_.lock();
-
-  if (!ipm) {
-    // TODO(ivanpauno): should this raise an error?
-    RCLCPP_WARN(
-      rclcpp::get_logger("rclcpp"),
-      "Intra process manager died for a publisher.");
-    return 0u;
-  }
-
-  return ipm->lowest_available_capacity(intra_process_publisher_id_);
-}

rclcpp/src/rclcpp/subscription_base.cpp

@@ -52,7 +52,7 @@ SubscriptionBase::SubscriptionBase(
   intra_process_subscription_id_(0),
   event_callbacks_(event_callbacks),
   type_support_(type_support_handle),
-  delivered_message_kind_(delivered_message_kind)
+  delivered_message_type_(delivered_message_kind)
 {
   auto custom_deletor = [node_handle = this->node_handle_](rcl_subscription_t * rcl_subs)
     {
@@ -218,7 +218,7 @@ SubscriptionBase::take_type_erased(void * message_out, rclcpp::MessageInfo & mes
     &message_info_out.get_rmw_message_info(),
     nullptr  // rmw_subscription_allocation_t is unused here
   );
-  TRACETOOLS_TRACEPOINT(rclcpp_take, static_cast<const void *>(message_out));
+  TRACEPOINT(rclcpp_take, static_cast<const void *>(message_out));
   if (RCL_RET_SUBSCRIPTION_TAKE_FAILED == ret) {
     return false;
   } else if (RCL_RET_OK != ret) {
@@ -261,13 +261,13 @@ SubscriptionBase::get_message_type_support_handle() const
 bool
 SubscriptionBase::is_serialized() const
 {
-  return delivered_message_kind_ == rclcpp::DeliveredMessageKind::SERIALIZED_MESSAGE;
+  return delivered_message_type_ == rclcpp::DeliveredMessageKind::SERIALIZED_MESSAGE;
 }
 
 rclcpp::DeliveredMessageKind
-SubscriptionBase::get_delivered_message_kind() const
+SubscriptionBase::get_subscription_type() const
 {
-  return delivered_message_kind_;
+  return delivered_message_type_;
 }
 
 size_t

rclcpp/test/rclcpp/CMakeLists.txt

@@ -649,13 +649,6 @@ if(TARGET test_wait_for_message)
   target_link_libraries(test_wait_for_message ${PROJECT_NAME})
 endif()
 
-ament_add_gtest(test_logger_service test_logger_service.cpp)
-if(TARGET test_logger_service)
-  ament_target_dependencies(test_logger_service
-    "rcl_interfaces")
-  target_link_libraries(test_logger_service ${PROJECT_NAME})
-endif()
-
 ament_add_gtest(test_interface_traits test_interface_traits.cpp
   APPEND_LIBRARY_DIRS "${append_library_dirs}")
 if(TARGET test_interface_traits)

rclcpp/test/rclcpp/executors/test_executors.cpp

@@ -20,14 +20,12 @@
 #include <gtest/gtest.h>
 
 #include <algorithm>
-#include <atomic>
 #include <chrono>
 #include <limits>
 #include <memory>
 #include <string>
 #include <thread>
 #include <utility>
-#include <vector>
 
 #include "rcl/error_handling.h"
 #include "rcl/time.h"
@@ -45,10 +43,18 @@ template<typename T>
 class TestExecutors : public ::testing::Test
 {
 public:
-  void SetUp()
+  static void SetUpTestCase()
   {
     rclcpp::init(0, nullptr);
+  }
 
+  static void TearDownTestCase()
+  {
+    rclcpp::shutdown();
+  }
+
+  void SetUp()
+  {
     const auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
     std::stringstream test_name;
     test_name << test_info->test_case_name() << "_" << test_info->name();
@@ -69,8 +75,6 @@ public:
     publisher.reset();
     subscription.reset();
     node.reset();
-
-    rclcpp::shutdown();
   }
 
   rclcpp::Node::SharedPtr node;
@@ -714,77 +718,6 @@ TYPED_TEST(TestExecutors, testSpinUntilFutureCompleteInterrupted)
   spinner.join();
 }
 
-// This test verifies that the add_node operation is robust wrt race conditions.
-// It's mostly meant to prevent regressions in the events-executor, but the operation should be
-// thread-safe in all executor implementations.
-// The initial implementation of the events-executor contained a bug where the executor
-// would end up in an inconsistent state and stop processing interrupt/shutdown notifications.
-// Manually adding a node to the executor results in a) producing a notify waitable event
-// and b) refreshing the executor collections.
-// The inconsistent state would happen if the event was processed before the collections were
-// finished to be refreshed: the executor would pick up the event but be unable to process it.
-// This would leave the `notify_waitable_event_pushed_` flag to true, preventing additional
-// notify waitable events to be pushed.
-// The behavior is observable only under heavy load, so this test spawns several worker
-// threads. Due to the nature of the bug, this test may still succeed even if the
-// bug is present. However repeated runs will show its flakiness nature and indicate
-// an eventual regression.
-TYPED_TEST(TestExecutors, testRaceConditionAddNode)
-{
-  using ExecutorType = TypeParam;
-  // rmw_connextdds doesn't support events-executor
-  if (
-    std::is_same<ExecutorType, rclcpp::experimental::executors::EventsExecutor>() &&
-    std::string(rmw_get_implementation_identifier()).find("rmw_connextdds") == 0)
-  {
-    GTEST_SKIP();
-  }
-
-  // Spawn some threads to do some heavy work
-  std::atomic<bool> should_cancel = false;
-  std::vector<std::thread> stress_threads;
-  for (size_t i = 0; i < 5 * std::thread::hardware_concurrency(); i++) {
-    stress_threads.emplace_back(
-      [&should_cancel, i]() {
-        // This is just some arbitrary heavy work
-        volatile size_t total = 0;
-        for (size_t k = 0; k < 549528914167; k++) {
-          if (should_cancel) {
-            break;
-          }
-          total += k * (i + 42);
-        }
-      });
-  }
-
-  // Create an executor
-  auto executor = std::make_shared<ExecutorType>();
-  // Start spinning
-  auto executor_thread = std::thread(
-    [executor]() {
-      executor->spin();
-    });
-  // Add a node to the executor
-  executor->add_node(this->node);
-
-  // Cancel the executor (make sure that it's already spinning first)
-  while (!executor->is_spinning() && rclcpp::ok()) {
-    continue;
-  }
-  executor->cancel();
-
-  // Try to join the thread after cancelling the executor
-  // This is the "test". We want to make sure that we can still cancel the executor
-  // regardless of the presence of race conditions
-  executor_thread.join();
-
-  // The test is now completed: we can join the stress threads
-  should_cancel = true;
-  for (auto & t : stress_threads) {
-    t.join();
-  }
-}
-
 // Check spin_until_future_complete with node base pointer (instantiates its own executor)
 TEST(TestExecutors, testSpinUntilFutureCompleteNodeBasePtr)
 {

rclcpp/test/rclcpp/test_intra_process_buffer.cpp

@@ -238,75 +238,3 @@ TEST(TestIntraProcessBuffer, unique_buffer_consume) {
   EXPECT_EQ(original_value, *popped_unique_msg);
   EXPECT_EQ(original_message_pointer, popped_message_pointer);
 }
-
-/*
-  Check the available buffer capacity while storing and consuming data from an intra-process
-  buffer.
-  The initial available buffer capacity should equal the buffer size.
-  Inserting a message should decrease the available buffer capacity by 1.
-  Consuming a message should increase the available buffer capacity by 1.
- */
-TEST(TestIntraProcessBuffer, available_capacity) {
-  using MessageT = char;
-  using Alloc = std::allocator<void>;
-  using Deleter = std::default_delete<MessageT>;
-  using SharedMessageT = std::shared_ptr<const MessageT>;
-  using UniqueMessageT = std::unique_ptr<MessageT, Deleter>;
-  using UniqueIntraProcessBufferT = rclcpp::experimental::buffers::TypedIntraProcessBuffer<
-    MessageT, Alloc, Deleter, UniqueMessageT>;
-
-  constexpr auto history_depth = 5u;
-
-  auto buffer_impl =
-    std::make_unique<rclcpp::experimental::buffers::RingBufferImplementation<UniqueMessageT>>(
-    history_depth);
-
-  UniqueIntraProcessBufferT intra_process_buffer(std::move(buffer_impl));
-
-  EXPECT_EQ(history_depth, intra_process_buffer.available_capacity());
-
-  auto original_unique_msg = std::make_unique<char>('a');
-  auto original_message_pointer = reinterpret_cast<std::uintptr_t>(original_unique_msg.get());
-  auto original_value = *original_unique_msg;
-
-  intra_process_buffer.add_unique(std::move(original_unique_msg));
-
-  EXPECT_EQ(history_depth - 1u, intra_process_buffer.available_capacity());
-
-  SharedMessageT popped_shared_msg;
-  popped_shared_msg = intra_process_buffer.consume_shared();
-  auto popped_message_pointer = reinterpret_cast<std::uintptr_t>(popped_shared_msg.get());
-
-  EXPECT_EQ(history_depth, intra_process_buffer.available_capacity());
-  EXPECT_EQ(original_value, *popped_shared_msg);
-  EXPECT_EQ(original_message_pointer, popped_message_pointer);
-
-  original_unique_msg = std::make_unique<char>('b');
-  original_message_pointer = reinterpret_cast<std::uintptr_t>(original_unique_msg.get());
-  original_value = *original_unique_msg;
-
-  intra_process_buffer.add_unique(std::move(original_unique_msg));
-
-  auto second_unique_msg = std::make_unique<char>('c');
-  auto second_message_pointer = reinterpret_cast<std::uintptr_t>(second_unique_msg.get());
-  auto second_value = *second_unique_msg;
-
-  intra_process_buffer.add_unique(std::move(second_unique_msg));
-
-  EXPECT_EQ(history_depth - 2u, intra_process_buffer.available_capacity());
-
-  UniqueMessageT popped_unique_msg;
-  popped_unique_msg = intra_process_buffer.consume_unique();
-  popped_message_pointer = reinterpret_cast<std::uintptr_t>(popped_unique_msg.get());
-
-  EXPECT_EQ(history_depth - 1u, intra_process_buffer.available_capacity());
-  EXPECT_EQ(original_value, *popped_unique_msg);
-  EXPECT_EQ(original_message_pointer, popped_message_pointer);
-
-  popped_unique_msg = intra_process_buffer.consume_unique();
-  popped_message_pointer = reinterpret_cast<std::uintptr_t>(popped_unique_msg.get());
-
-  EXPECT_EQ(history_depth, intra_process_buffer.available_capacity());
-  EXPECT_EQ(second_value, *popped_unique_msg);
-  EXPECT_EQ(second_message_pointer, popped_message_pointer);
-}

rclcpp/test/rclcpp/test_intra_process_manager.cpp

@@ -156,26 +156,18 @@ public:
   {
     message_ptr = reinterpret_cast<std::uintptr_t>(msg.get());
     shared_msg = msg;
-    ++num_msgs;
   }
 
   void add(MessageUniquePtr msg)
   {
     message_ptr = reinterpret_cast<std::uintptr_t>(msg.get());
     unique_msg = std::move(msg);
-    ++num_msgs;
   }
 
   void pop(std::uintptr_t & msg_ptr)
   {
     msg_ptr = message_ptr;
     message_ptr = 0;
-    --num_msgs;
-  }
-
-  size_t size() const
-  {
-    return num_msgs;
   }
 
   // need to store the messages somewhere otherwise the memory address will be reused
@@ -183,8 +175,6 @@ public:
   MessageUniquePtr unique_msg;
 
   std::uintptr_t message_ptr;
-  // count add and pop
-  size_t num_msgs = 0u;
 };
 
 }  // namespace mock
@@ -231,10 +221,6 @@ public:
     return topic_name.c_str();
   }
 
-  virtual
-  size_t
-  available_capacity() const = 0;
-
   rclcpp::QoS qos_profile;
   std::string topic_name;
 };
@@ -294,12 +280,6 @@ public:
     return take_shared_method;
   }
 
-  size_t
-  available_capacity() const override
-  {
-    return qos_profile.depth() - buffer->size();
-  }
-
   bool take_shared_method;
 
   typename rclcpp::experimental::buffers::mock::IntraProcessBuffer<MessageT>::UniquePtr buffer;
@@ -732,91 +712,3 @@ TEST(TestIntraProcessManager, multiple_subscriptions_different_type) {
   EXPECT_EQ(original_message_pointer, received_message_pointer_10);
   EXPECT_NE(original_message_pointer, received_message_pointer_11);
 }
-
-/*
-   This tests the method "lowest_available_capacity":
-   - Creates 1 publisher.
-   - The available buffer capacity should be at least history size.
-   - Add 2 subscribers.
-   - Add everything to the intra-process manager.
-   - All the entities are expected to have different ids.
-   - Check the subscriptions count for the publisher.
-   - The available buffer capacity should be the history size.
-   - Publish one message (without receiving it).
-   - The available buffer capacity should decrease by 1.
-   - Publish another message (without receiving it).
-   - The available buffer capacity should decrease by 1.
-   - One subscriber receives one message.
-   - The available buffer capacity should stay the same,
-     as the other subscriber still has not freed its buffer.
-   - The other subscriber receives one message.
-   - The available buffer capacity should increase by 1.
-   - One subscription goes out of scope.
-   - The available buffer capacity should not change.
- */
-TEST(TestIntraProcessManager, lowest_available_capacity) {
-  using IntraProcessManagerT = rclcpp::experimental::IntraProcessManager;
-  using MessageT = rcl_interfaces::msg::Log;
-  using PublisherT = rclcpp::mock::Publisher<MessageT>;
-  using SubscriptionIntraProcessT = rclcpp::experimental::mock::SubscriptionIntraProcess<MessageT>;
-
-  constexpr auto history_depth = 10u;
-
-  auto ipm = std::make_shared<IntraProcessManagerT>();
-
-  auto p1 = std::make_shared<PublisherT>(rclcpp::QoS(history_depth).best_effort());
-
-  auto s1 = std::make_shared<SubscriptionIntraProcessT>(rclcpp::QoS(history_depth).best_effort());
-  auto s2 = std::make_shared<SubscriptionIntraProcessT>(rclcpp::QoS(history_depth).best_effort());
-
-  auto p1_id = ipm->add_publisher(p1);
-  p1->set_intra_process_manager(p1_id, ipm);
-
-  auto c1 = ipm->lowest_available_capacity(p1_id);
-
-  ASSERT_LE(0u, c1);
-
-  auto s1_id = ipm->add_subscription(s1);
-  auto s2_id = ipm->add_subscription(s2);
-
-  bool unique_ids = s1_id != s2_id && p1_id != s1_id;
-  ASSERT_TRUE(unique_ids);
-
-  size_t p1_subs = ipm->get_subscription_count(p1_id);
-  size_t non_existing_pub_subs = ipm->get_subscription_count(42);
-  ASSERT_EQ(2u, p1_subs);
-  ASSERT_EQ(0u, non_existing_pub_subs);
-
-  c1 = ipm->lowest_available_capacity(p1_id);
-  auto non_existing_pub_c = ipm->lowest_available_capacity(42);
-
-  ASSERT_EQ(history_depth, c1);
-  ASSERT_EQ(0u, non_existing_pub_c);
-
-  auto unique_msg = std::make_unique<MessageT>();
-  p1->publish(std::move(unique_msg));
-
-  c1 = ipm->lowest_available_capacity(p1_id);
-  ASSERT_EQ(history_depth - 1u, c1);
-
-  unique_msg = std::make_unique<MessageT>();
-  p1->publish(std::move(unique_msg));
-
-  c1 = ipm->lowest_available_capacity(p1_id);
-  ASSERT_EQ(history_depth - 2u, c1);
-
-  s1->pop();
-
-  c1 = ipm->lowest_available_capacity(p1_id);
-  ASSERT_EQ(history_depth - 2u, c1);
-
-  s2->pop();
-
-  c1 = ipm->lowest_available_capacity(p1_id);
-  ASSERT_EQ(history_depth - 1u, c1);
-
-  ipm->get_subscription_intra_process(s1_id).reset();
-
-  c1 = ipm->lowest_available_capacity(p1_id);
-  ASSERT_EQ(history_depth - 1u, c1);
-}

rclcpp/test/rclcpp/test_logger_service.cpp

@@ -1,214 +0,0 @@
-// Copyright 2023 Sony Group Corporation.
-//
-// 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 <memory>
-#include <string>
-#include <vector>
-
-#include "rclcpp/rclcpp.hpp"
-#include "rclcpp/node.hpp"
-#include "rcl_interfaces/srv/get_logger_levels.hpp"
-#include "rcl_interfaces/srv/set_logger_levels.hpp"
-
-using namespace std::chrono_literals;
-
-class TestLoggerService : public ::testing::Test
-{
-protected:
-  void SetUp()
-  {
-    rclcpp::init(0, nullptr);
-    rclcpp::NodeOptions options = rclcpp::NodeOptions();
-    options.enable_logger_service(true);
-    node_ = std::make_shared<rclcpp::Node>("test_logger_service", "/test", options);
-  }
-
-  void TearDown()
-  {
-    rclcpp::shutdown();
-  }
-
-  rclcpp::Node::SharedPtr node_;
-  std::thread thread_;
-};
-
-TEST_F(TestLoggerService, check_connect_get_logger_service) {
-  auto client = node_->create_client<rcl_interfaces::srv::GetLoggerLevels>(
-    "/test/test_logger_service/get_logger_levels");
-  ASSERT_TRUE(client->wait_for_service(2s));
-}
-
-TEST_F(TestLoggerService, check_connect_set_logger_service) {
-  auto client = node_->create_client<rcl_interfaces::srv::SetLoggerLevels>(
-    "/test/test_logger_service/set_logger_levels");
-  ASSERT_TRUE(client->wait_for_service(2s));
-}
-
-TEST_F(TestLoggerService, test_set_and_get_one_logging_level) {
-  std::string test_logger_name = "rcl";
-  uint8_t test_logger_level = 20;
-  {
-    auto client = node_->create_client<rcl_interfaces::srv::SetLoggerLevels>(
-      "/test/test_logger_service/set_logger_levels");
-    ASSERT_TRUE(client->wait_for_service(1s));
-    auto request = std::make_shared<rcl_interfaces::srv::SetLoggerLevels::Request>();
-    auto level = rcl_interfaces::msg::LoggerLevel();
-    level.name = test_logger_name;
-    level.level = test_logger_level;
-    request->levels.push_back(level);
-    auto result = client->async_send_request(request);
-    ASSERT_EQ(
-      rclcpp::spin_until_future_complete(node_, result),
-      rclcpp::FutureReturnCode::SUCCESS);
-    auto result_get = result.get();
-    ASSERT_EQ(result_get->results.size(), 1u);
-    ASSERT_TRUE(result_get->results[0].successful);
-    ASSERT_STREQ(result_get->results[0].reason.c_str(), "");
-  }
-
-  {
-    auto client = node_->create_client<rcl_interfaces::srv::GetLoggerLevels>(
-      "/test/test_logger_service/get_logger_levels");
-    ASSERT_TRUE(client->wait_for_service(1s));
-    auto request = std::make_shared<rcl_interfaces::srv::GetLoggerLevels::Request>();
-    request->names.emplace_back(test_logger_name);
-    auto result = client->async_send_request(request);
-    ASSERT_EQ(
-      rclcpp::spin_until_future_complete(node_, result),
-      rclcpp::FutureReturnCode::SUCCESS);
-    auto result_get = result.get();
-    ASSERT_EQ(result_get->levels.size(), 1u);
-    ASSERT_STREQ(result_get->levels[0].name.c_str(), test_logger_name.c_str());
-    ASSERT_EQ(result_get->levels[0].level, test_logger_level);
-  }
-}
-
-TEST_F(TestLoggerService, test_set_and_get_multi_logging_level) {
-  std::vector<std::pair<std::string, uint8_t>> test_data {
-    {"rcl", 30},
-    {"rclcpp", 40},
-    {"/test/test_logger_service", 50}
-  };
-
-  // Set multi log levels
-  {
-    auto client = node_->create_client<rcl_interfaces::srv::SetLoggerLevels>(
-      "/test/test_logger_service/set_logger_levels");
-    ASSERT_TRUE(client->wait_for_service(1s));
-    auto request = std::make_shared<rcl_interfaces::srv::SetLoggerLevels::Request>();
-    for (auto & set_level : test_data) {
-      auto level = rcl_interfaces::msg::LoggerLevel();
-      level.name = std::get<0>(set_level);
-      level.level = std::get<1>(set_level);
-      request->levels.push_back(level);
-    }
-    auto result = client->async_send_request(request);
-    ASSERT_EQ(
-      rclcpp::spin_until_future_complete(node_, result),
-      rclcpp::FutureReturnCode::SUCCESS);
-    auto result_get = result.get();
-    ASSERT_EQ(result_get->results.size(), test_data.size());
-    for (uint32_t i = 0; i < test_data.size(); i++) {
-      ASSERT_TRUE(result_get->results[0].successful);
-    }
-  }
-
-  // Get multi log levels
-  {
-    auto client = node_->create_client<rcl_interfaces::srv::GetLoggerLevels>(
-      "/test/test_logger_service/get_logger_levels");
-    ASSERT_TRUE(client->wait_for_service(1s));
-    auto request = std::make_shared<rcl_interfaces::srv::GetLoggerLevels::Request>();
-    for (auto & set_level : test_data) {
-      request->names.emplace_back(std::get<0>(set_level));
-    }
-    auto result = client->async_send_request(request);
-    ASSERT_EQ(
-      rclcpp::spin_until_future_complete(node_, result),
-      rclcpp::FutureReturnCode::SUCCESS);
-    auto result_get = result.get();
-    ASSERT_EQ(result_get->levels.size(), test_data.size());
-    for (uint32_t i = 0; i < test_data.size(); i++) {
-      ASSERT_STREQ(result_get->levels[i].name.c_str(), std::get<0>(test_data[i]).c_str());
-      ASSERT_EQ(result_get->levels[i].level, std::get<1>(test_data[i]));
-    }
-  }
-}
-
-TEST_F(TestLoggerService, test_set_logging_level_with_invalid_param) {
-  std::vector<std::pair<std::string, uint8_t>> test_data {
-    {"rcl", 12},
-    {"/test/test_logger_service", 22}
-  };
-
-  // Set multi log levels
-  {
-    auto client = node_->create_client<rcl_interfaces::srv::SetLoggerLevels>(
-      "/test/test_logger_service/set_logger_levels");
-    ASSERT_TRUE(client->wait_for_service(1s));
-    auto request = std::make_shared<rcl_interfaces::srv::SetLoggerLevels::Request>();
-    for (auto & set_level : test_data) {
-      auto level = rcl_interfaces::msg::LoggerLevel();
-      level.name = std::get<0>(set_level);
-      level.level = std::get<1>(set_level);
-      request->levels.push_back(level);
-    }
-    auto result = client->async_send_request(request);
-    ASSERT_EQ(
-      rclcpp::spin_until_future_complete(node_, result),
-      rclcpp::FutureReturnCode::SUCCESS);
-    auto result_get = result.get();
-    ASSERT_EQ(result_get->results.size(), test_data.size());
-    for (uint32_t i = 0; i < test_data.size(); i++) {
-      ASSERT_FALSE(result_get->results[i].successful);
-      // Check string starts with prefix
-      ASSERT_EQ(
-        result_get->results[i].reason.rfind("Unable to determine severity_string for severity", 0),
-        0);
-    }
-  }
-}
-
-TEST_F(TestLoggerService, test_set_logging_level_with_partial_invalid_param) {
-  std::vector<std::pair<std::string, uint8_t>> test_data {
-    {"rcl", 20},
-    {"rclcpp", 22},
-    {"/test/test_logger_service", 30}
-  };
-
-  // Set multi log levels
-  {
-    auto client = node_->create_client<rcl_interfaces::srv::SetLoggerLevels>(
-      "/test/test_logger_service/set_logger_levels");
-    ASSERT_TRUE(client->wait_for_service(1s));
-    auto request = std::make_shared<rcl_interfaces::srv::SetLoggerLevels::Request>();
-    for (auto & set_level : test_data) {
-      auto level = rcl_interfaces::msg::LoggerLevel();
-      level.name = std::get<0>(set_level);
-      level.level = std::get<1>(set_level);
-      request->levels.push_back(level);
-    }
-    auto result = client->async_send_request(request);
-    ASSERT_EQ(
-      rclcpp::spin_until_future_complete(node_, result),
-      rclcpp::FutureReturnCode::SUCCESS);
-    auto result_get = result.get();
-    ASSERT_EQ(result_get->results.size(), test_data.size());
-    ASSERT_TRUE(result_get->results[0].successful);
-    ASSERT_FALSE(result_get->results[1].successful);
-    ASSERT_TRUE(result_get->results[2].successful);
-  }
-}

rclcpp/test/rclcpp/test_node_options.cpp

@@ -266,11 +266,6 @@ TEST(TestNodeOptions, bool_setters_and_getters) {
   EXPECT_FALSE(options.automatically_declare_parameters_from_overrides());
   options.automatically_declare_parameters_from_overrides(true);
   EXPECT_TRUE(options.automatically_declare_parameters_from_overrides());
-
-  options.enable_logger_service(false);
-  EXPECT_FALSE(options.enable_logger_service());
-  options.enable_logger_service(true);
-  EXPECT_TRUE(options.enable_logger_service());
 }
 
 TEST(TestNodeOptions, parameter_event_qos) {

rclcpp/test/rclcpp/test_publisher.cpp

@@ -629,41 +629,6 @@ TEST_P(TestPublisherWaitForAllAcked, check_wait_for_all_acked_with_QosPolicy) {
   EXPECT_TRUE(pub->wait_for_all_acked(std::chrono::milliseconds(6000)));
 }
 
-TEST_F(TestPublisher, lowest_available_ipm_capacity) {
-  constexpr auto history_depth = 10u;
-
-  initialize(rclcpp::NodeOptions().use_intra_process_comms(true));
-
-  rclcpp::PublisherOptionsWithAllocator<std::allocator<void>> options_ipm_disabled;
-  options_ipm_disabled.use_intra_process_comm = rclcpp::IntraProcessSetting::Disable;
-
-  rclcpp::PublisherOptionsWithAllocator<std::allocator<void>> options_ipm_enabled;
-  options_ipm_enabled.use_intra_process_comm = rclcpp::IntraProcessSetting::Enable;
-
-  auto do_nothing = [](std::shared_ptr<const test_msgs::msg::Strings>) {};
-  auto pub_ipm_disabled = node->create_publisher<test_msgs::msg::Strings>(
-    "topic", history_depth,
-    options_ipm_disabled);
-  auto pub_ipm_enabled = node->create_publisher<test_msgs::msg::Strings>(
-    "topic", history_depth,
-    options_ipm_enabled);
-  auto sub = node->create_subscription<test_msgs::msg::Strings>(
-    "topic",
-    history_depth,
-    do_nothing);
-
-  ASSERT_EQ(1, pub_ipm_enabled->get_intra_process_subscription_count());
-  ASSERT_EQ(0, pub_ipm_disabled->lowest_available_ipm_capacity());
-  ASSERT_EQ(history_depth, pub_ipm_enabled->lowest_available_ipm_capacity());
-
-  auto msg = std::make_shared<test_msgs::msg::Strings>();
-  ASSERT_NO_THROW(pub_ipm_disabled->publish(*msg));
-  ASSERT_NO_THROW(pub_ipm_enabled->publish(*msg));
-
-  ASSERT_EQ(0, pub_ipm_disabled->lowest_available_ipm_capacity());
-  ASSERT_EQ(history_depth - 1u, pub_ipm_enabled->lowest_available_ipm_capacity());
-}
-
 INSTANTIATE_TEST_SUITE_P(
   TestWaitForAllAckedWithParm,
   TestPublisherWaitForAllAcked,

rclcpp/test/rclcpp/test_rosout_subscription.cpp

@@ -70,7 +70,7 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_getchild) {
     // before calling get_child of Logger
     {
       RCLCPP_INFO(
-        rclcpp::get_logger(logger_name), "%s", this->rosout_msg_data.c_str());
+        rclcpp::get_logger(logger_name), this->rosout_msg_data.c_str());
       auto future = received_msg_promise.get_future();
       auto return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
       ASSERT_EQ(rclcpp::FutureReturnCode::TIMEOUT, return_code);
@@ -83,7 +83,7 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_getchild) {
     // after calling get_child of Logger
     // 1. use child_logger directly
     {
-      RCLCPP_INFO(child_logger, "%s", this->rosout_msg_data.c_str());
+      RCLCPP_INFO(child_logger, this->rosout_msg_data.c_str());
       auto future = received_msg_promise.get_future();
       auto return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
       ASSERT_EQ(rclcpp::FutureReturnCode::SUCCESS, return_code);
@@ -93,7 +93,7 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_getchild) {
 
     // 2. use rclcpp::get_logger
     {
-      RCLCPP_INFO(rclcpp::get_logger(logger_name), "%s", this->rosout_msg_data.c_str());
+      RCLCPP_INFO(rclcpp::get_logger(logger_name), this->rosout_msg_data.c_str());
       auto future = received_msg_promise.get_future();
       auto return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
       ASSERT_EQ(rclcpp::FutureReturnCode::SUCCESS, return_code);
@@ -104,7 +104,7 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_getchild) {
 
   // `child_logger` is end of life, there is no sublogger
   {
-    RCLCPP_INFO(rclcpp::get_logger(logger_name), "%s", this->rosout_msg_data.c_str());
+    RCLCPP_INFO(rclcpp::get_logger(logger_name), this->rosout_msg_data.c_str());
     auto future = received_msg_promise.get_future();
     auto return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
     ASSERT_EQ(rclcpp::FutureReturnCode::TIMEOUT, return_code);
@@ -119,7 +119,7 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_parent_log) {
 
   rclcpp::Logger logger = this->node->get_logger();
   ASSERT_EQ(logger.get_name(), logger_name);
-  RCLCPP_INFO(logger, "%s", this->rosout_msg_data.c_str());
+  RCLCPP_INFO(logger, this->rosout_msg_data.c_str());
   auto future = received_msg_promise.get_future();
   auto return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
   ASSERT_EQ(rclcpp::FutureReturnCode::SUCCESS, return_code);
@@ -133,14 +133,14 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_child_log) {
   this->rosout_msg_name = logger_name;
 
   rclcpp::Logger logger = this->node->get_logger();
-  RCLCPP_INFO(logger, "%s", this->rosout_msg_data.c_str());
+  RCLCPP_INFO(logger, this->rosout_msg_data.c_str());
   auto future = received_msg_promise.get_future();
   auto return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
   ASSERT_EQ(rclcpp::FutureReturnCode::TIMEOUT, return_code);
   received_msg_promise = {};
 
   logger = this->node->get_logger().get_child("child1");
-  RCLCPP_INFO(logger, "%s", this->rosout_msg_data.c_str());
+  RCLCPP_INFO(logger, this->rosout_msg_data.c_str());
   future = received_msg_promise.get_future();
   return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
   ASSERT_EQ(rclcpp::FutureReturnCode::SUCCESS, return_code);
@@ -148,14 +148,14 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_child_log) {
   received_msg_promise = {};
 
   logger = this->node->get_logger().get_child("child2");
-  RCLCPP_INFO(logger, "%s", this->rosout_msg_data.c_str());
+  RCLCPP_INFO(logger, this->rosout_msg_data.c_str());
   future = received_msg_promise.get_future();
   return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
   ASSERT_EQ(rclcpp::FutureReturnCode::TIMEOUT, return_code);
   received_msg_promise = {};
 
   this->rosout_msg_name = "ns.test_rosout_subscription.child2";
-  RCLCPP_INFO(logger, "%s", this->rosout_msg_data.c_str());
+  RCLCPP_INFO(logger, this->rosout_msg_data.c_str());
   future = received_msg_promise.get_future();
   return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
   ASSERT_EQ(rclcpp::FutureReturnCode::SUCCESS, return_code);
@@ -171,7 +171,7 @@ TEST_F(TestRosoutSubscription, test_rosoutsubscription_getchild_hierarchy) {
   rclcpp::Logger grandchild_logger =
     this->node->get_logger().get_child("child").get_child("grandchild");
   ASSERT_EQ(grandchild_logger.get_name(), logger_name);
-  RCLCPP_INFO(grandchild_logger, "%s", this->rosout_msg_data.c_str());
+  RCLCPP_INFO(grandchild_logger, this->rosout_msg_data.c_str());
   auto future = received_msg_promise.get_future();
   auto return_code = rclcpp::spin_until_future_complete(this->node, future, 3s);
   ASSERT_EQ(rclcpp::FutureReturnCode::SUCCESS, return_code);

rclcpp/test/rclcpp/test_timers_manager.cpp

@@ -296,7 +296,7 @@ TEST_F(TestTimersManager, timers_thread)
 
   // Run timers thread for a while
   timers_manager->start();
-  std::this_thread::sleep_for(10ms);
+  std::this_thread::sleep_for(5ms);
   timers_manager->stop();
 
   EXPECT_LT(1u, t1_runs);

rclcpp_action/CHANGELOG.rst

@@ -3,18 +3,6 @@ Changelog for package rclcpp_action
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-21.2.0 (2023-06-07)
--------------------
-
-21.1.1 (2023-05-11)
--------------------
-
-21.1.0 (2023-04-27)
--------------------
-
-21.0.0 (2023-04-18)
--------------------
-
 20.0.0 (2023-04-13)
 -------------------
 * extract the result response before the callback is issued. (`#2132 <https://github.com/ros2/rclcpp/issues/2132>`_)

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>21.2.0</version>
+  <version>20.0.0</version>
   <description>Adds action APIs for C++.</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp_components/CHANGELOG.rst

@@ -2,18 +2,6 @@
 Changelog for package rclcpp_components
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-21.2.0 (2023-06-07)
--------------------
-
-21.1.1 (2023-05-11)
--------------------
-
-21.1.0 (2023-04-27)
--------------------
-
-21.0.0 (2023-04-18)
--------------------
-
 20.0.0 (2023-04-13)
 -------------------
 * Update all rclcpp packages to C++17. (`#2121 <https://github.com/ros2/rclcpp/issues/2121>`_)

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>21.2.0</version>
+  <version>20.0.0</version>
   <description>Package containing tools for dynamically loadable components</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp_lifecycle/CHANGELOG.rst

@@ -3,21 +3,6 @@ Changelog for package rclcpp_lifecycle
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-21.2.0 (2023-06-07)
--------------------
-
-21.1.1 (2023-05-11)
--------------------
-
-21.1.0 (2023-04-27)
--------------------
-
-21.0.0 (2023-04-18)
--------------------
-* Add support for logging service. (`#2122 <https://github.com/ros2/rclcpp/issues/2122>`_)
-* Support publishing loaned messages in LifecyclePublisher (`#2159 <https://github.com/ros2/rclcpp/issues/2159>`_)
-* Contributors: Lei Liu, Michael Babenko
-
 20.0.0 (2023-04-13)
 -------------------
 * Fixes to silence some clang warnings. (`#2127 <https://github.com/ros2/rclcpp/issues/2127>`_)

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>21.2.0</version>
+  <version>20.0.0</version>
   <description>Package containing a prototype for lifecycle implementation</description>
 
   <maintainer email="ivanpauno@ekumenlabs.com">Ivan Paunovic</maintainer>

rclcpp_lifecycle/src/lifecycle_node.cpp

@@ -76,7 +76,7 @@ LifecycleNode::LifecycleNode(
       options.use_intra_process_comms(),
       options.enable_topic_statistics())),
   node_graph_(new rclcpp::node_interfaces::NodeGraph(node_base_.get())),
-  node_logging_(new rclcpp::node_interfaces::NodeLogging(node_base_)),
+  node_logging_(new rclcpp::node_interfaces::NodeLogging(node_base_.get())),
   node_timers_(new rclcpp::node_interfaces::NodeTimers(node_base_.get())),
   node_topics_(new rclcpp::node_interfaces::NodeTopics(node_base_.get(), node_timers_.get())),
   node_services_(new rclcpp::node_interfaces::NodeServices(node_base_.get())),