Use a single executor instance for spinning in client_async_callback. (#382)

In the current code, it calls rclpy.spin_once(), which
instantiates a new executor, adds the node to it, executors
one work item, then removes the node and destroys the executor.

Besides being inefficient, the problem with that sequence
is that adding a node to the executor actually ends up
being an "event", and so the work item that gets returned
can be just the work of adding the node, over and over again.
For reasons I admit I don't fully understand, this only happens
with rmw_cyclonedds_cpp, not with rmw_fastrtps_cpp.

Regardless, the much more performant thing to do is to create
an executor at the beginning of the example and to just spin
on that.  This eliminates adding it to the node constantly,
and makes this work with all RMWs.

Signed-off-by: Chris Lalancette <[email protected]>
(cherry picked from commit 7e47aee)

# Conflicts:
#	rclpy/services/minimal_client/examples_rclpy_minimal_client/client_async_callback.py

Author: clalancette

rclpy/services/minimal_client/examples_rclpy_minimal_client/client_async_callback.py

@@ -29,6 +29,7 @@ def main(args=None):
     did_run = False
     did_get_result = False
 
+<<<<<<< HEAD
     async def call_service():
         nonlocal cli, node, did_run, did_get_result
         did_run = True
@@ -43,6 +44,21 @@ async def call_service():
                 (req.a, req.b, result.sum))
         finally:
             did_get_result = True
+=======
+    try:
+        node = rclpy.create_node('minimal_client')
+
+        executor = rclpy.executors.SingleThreadedExecutor()
+        executor.add_node(node)
+
+        # Node's default callback group is mutually exclusive. This would prevent the client
+        # response from being processed until the timer callback finished, but the timer callback
+        # in this example is waiting for the client response
+        cb_group = ReentrantCallbackGroup()
+        cli = node.create_client(AddTwoInts, 'add_two_ints', callback_group=cb_group)
+        did_run = False
+        did_get_result = False
+>>>>>>> 7e47aee (Use a single executor instance for spinning in client_async_callback. (#382))
 
     while not cli.wait_for_service(timeout_sec=1.0):
         node.get_logger().info('service not available, waiting again...')
@@ -52,15 +68,29 @@ async def call_service():
     while rclpy.ok() and not did_run:
         rclpy.spin_once(node)
 
+<<<<<<< HEAD
     if did_run:
         # call timer callback only once
         timer.cancel()
+=======
+        while rclpy.ok() and not did_run:
+            executor.spin_once()
+>>>>>>> 7e47aee (Use a single executor instance for spinning in client_async_callback. (#382))
 
     while rclpy.ok() and not did_get_result:
         rclpy.spin_once(node)
 
+<<<<<<< HEAD
     node.destroy_node()
     rclpy.shutdown()
+=======
+        while rclpy.ok() and not did_get_result:
+            executor.spin_once()
+    except KeyboardInterrupt:
+        pass
+    except ExternalShutdownException:
+        sys.exit(1)
+>>>>>>> 7e47aee (Use a single executor instance for spinning in client_async_callback. (#382))
 
 
 if __name__ == '__main__':