Convert Client to use C++ Class

rclpy/CMakeLists.txt

@@ -166,9 +166,11 @@ pybind11_add_module(_rclpy_pybind11 SHARED
   src/rclpy/client.cpp
   src/rclpy/clock.cpp
   src/rclpy/context.cpp
+  src/rclpy/destroyable.cpp
   src/rclpy/duration.cpp
   src/rclpy/graph.cpp
   src/rclpy/guard_condition.cpp
+  src/rclpy/handle.cpp
   src/rclpy/init.cpp
   src/rclpy/logging.cpp
   src/rclpy/names.cpp

rclpy/rclpy/client.py

@@ -33,7 +33,7 @@ class Client:
     def __init__(
         self,
         context: Context,
-        client_handle,
+        client_impl: _rclpy.Client,
         srv_type: SrvType,
         srv_name: str,
         qos_profile: QoSProfile,
@@ -46,15 +46,15 @@ def __init__(
            should call :meth:`.Node.create_client`.
 
         :param context: The context associated with the service client.
-        :param client_handle: :class:`Handle` wrapping the underlying ``rcl_client_t`` object.
+        :param client_impl: :class:`_rclpy.Client` wrapping the underlying ``rcl_client_t`` object.
         :param srv_type: The service type.
         :param srv_name: The name of the service.
         :param qos_profile: The quality of service profile to apply the service client.
         :param callback_group: The callback group for the service client. If ``None``, then the
             nodes default callback group is used.
         """
         self.context = context
-        self.__handle = client_handle
+        self.__client = client_impl
         self.srv_type = srv_type
         self.srv_name = srv_name
         self.qos_profile = qos_profile
@@ -122,8 +122,8 @@ def call_async(self, request: SrvTypeRequest) -> Future:
         if not isinstance(request, self.srv_type.Request):
             raise TypeError()
 
-        with self.handle as capsule:
-            sequence_number = _rclpy.rclpy_send_request(capsule, request)
+        with self.handle:
+            sequence_number = self.__client.send_request(request)
         if sequence_number in self._pending_requests:
             raise RuntimeError('Sequence (%r) conflicts with pending request' % sequence_number)
 
@@ -140,8 +140,8 @@ def service_is_ready(self) -> bool:
 
         :return: ``True`` if a server is ready, ``False`` otherwise.
         """
-        with self.handle as capsule:
-            return _rclpy.rclpy_service_server_is_available(capsule)
+        with self.handle:
+            return self.__client.service_server_is_available()
 
     def wait_for_service(self, timeout_sec: float = None) -> bool:
         """
@@ -165,7 +165,7 @@ def wait_for_service(self, timeout_sec: float = None) -> bool:
 
     @property
     def handle(self):
-        return self.__handle
+        return self.__client
 
     def destroy(self):
-        self.handle.destroy()
+        self.__client.destroy_when_not_in_use()

rclpy/rclpy/executors.py

@@ -340,8 +340,8 @@ async def _execute_subscription(self, sub, msg):
             await await_or_execute(sub.callback, msg)
 
     def _take_client(self, client):
-        with client.handle as capsule:
-            return _rclpy.rclpy_take_response(capsule, client.srv_type.Response)
+        with client.handle:
+            return client.handle.take_response(client.srv_type.Response)
 
     async def _execute_client(self, client, seq_and_response):
         header, response = seq_and_response
@@ -519,10 +519,11 @@ def _wait_for_ready_callbacks(
                     except InvalidHandle:
                         entity_count.num_subscriptions -= 1
 
-                client_capsules = []
+                client_handles = []
                 for cli in clients:
                     try:
-                        client_capsules.append(context_stack.enter_context(cli.handle))
+                        context_stack.enter_context(cli.handle)
+                        client_handles.append(cli.handle)
                     except InvalidHandle:
                         entity_count.num_clients -= 1
 
@@ -561,8 +562,8 @@ def _wait_for_ready_callbacks(
                 _rclpy.rclpy_wait_set_clear_entities(wait_set)
                 for sub_capsule in sub_capsules:
                     _rclpy.rclpy_wait_set_add_entity('subscription', wait_set, sub_capsule)
-                for cli_capsule in client_capsules:
-                    _rclpy.rclpy_wait_set_add_entity('client', wait_set, cli_capsule)
+                for cli_handle in client_handles:
+                    _rclpy.rclpy_wait_set_add_client(wait_set, cli_handle)
                 for srv_capsule in service_capsules:
                     _rclpy.rclpy_wait_set_add_entity('service', wait_set, srv_capsule)
                 for tmr_capsule in timer_capsules:

rclpy/rclpy/handle.py

@@ -15,11 +15,11 @@
 from threading import Lock
 
 from rclpy.impl.implementation_singleton import rclpy_handle_implementation as _rclpy_handle
+from rclpy.impl.implementation_singleton import rclpy_implementation as _rclpy
 from rclpy.impl.implementation_singleton import rclpy_pycapsule_implementation as _rclpy_capsule
 
 
-class InvalidHandle(Exception):
-    pass
+InvalidHandle = _rclpy.InvalidHandle
 
 
 class Handle:

rclpy/rclpy/node.py

@@ -1383,7 +1383,7 @@ def create_client(
         failed = False
         try:
             with self.handle as node_capsule:
-                client_capsule = _rclpy.rclpy_create_client(
+                client_impl = _rclpy.Client(
                     node_capsule,
                     srv_type,
                     srv_name,
@@ -1393,11 +1393,9 @@ def create_client(
         if failed:
             self._validate_topic_or_service_name(srv_name, is_service=True)
 
-        client_handle = Handle(client_capsule)
-
         client = Client(
             self.context,
-            client_handle, srv_type, srv_name, qos_profile,
+            client_impl, srv_type, srv_name, qos_profile,
             callback_group)
         self.__clients.append(client)
         callback_group.add_entity(client)

rclpy/src/rclpy/_rclpy_pybind11.cpp

@@ -19,6 +19,7 @@
 #include "client.hpp"
 #include "clock.hpp"
 #include "context.hpp"
+#include "destroyable.hpp"
 #include "duration.hpp"
 #include "graph.hpp"
 #include "guard_condition.hpp"
@@ -43,6 +44,8 @@ namespace py = pybind11;
 PYBIND11_MODULE(_rclpy_pybind11, m) {
   m.doc() = "ROS 2 Python client library.";
 
+  rclpy::define_destroyable(m);
+
   py::enum_<rcl_clock_type_t>(m, "ClockType")
   .value("UNINITIALIZED", RCL_CLOCK_UNINITIALIZED)
   .value("ROS_TIME", RCL_ROS_TIME)
@@ -100,6 +103,8 @@ PYBIND11_MODULE(_rclpy_pybind11, m) {
     m, "UnsupportedEventTypeError", rclerror.ptr());
   py::register_exception<rclpy::NotImplementedError>(
     m, "NotImplementedError", PyExc_NotImplementedError);
+  py::register_exception<rclpy::InvalidHandle>(
+    m, "InvalidHandle", PyExc_RuntimeError);
 
   m.def(
     "rclpy_init", &rclpy::init,
@@ -108,18 +113,7 @@ PYBIND11_MODULE(_rclpy_pybind11, m) {
     "rclpy_shutdown", &rclpy::shutdown,
     "rclpy_shutdown.");
 
-  m.def(
-    "rclpy_create_client", &rclpy::client_create,
-    "Create a Client");
-  m.def(
-    "rclpy_send_request", &rclpy::client_send_request,
-    "Send a request");
-  m.def(
-    "rclpy_service_server_is_available", &rclpy::client_service_server_is_available,
-    "Return true if the service server is available");
-  m.def(
-    "rclpy_take_response", &rclpy::client_take_response,
-    "rclpy_take_response");
+  rclpy::define_client(m);
 
   m.def(
     "rclpy_context_get_domain_id", &rclpy::context_get_domain_id,
@@ -268,6 +262,9 @@ PYBIND11_MODULE(_rclpy_pybind11, m) {
   m.def(
     "rclpy_wait_set_add_entity", &rclpy::wait_set_add_entity,
     "rclpy_wait_set_add_entity.");
+  m.def(
+    "rclpy_wait_set_add_client", &rclpy::wait_set_add_client,
+    "Add a client to the wait set.");
   m.def(
     "rclpy_wait_set_is_ready", &rclpy::wait_set_is_ready,
     "rclpy_wait_set_is_ready.");