add timeout arguments elsewhere

ros2action/ros2action/verb/send_goal.py

@@ -68,8 +68,10 @@ def add_arguments(self, parser, cli_name):
         parser.add_argument(
             '-t', '--timeout', metavar='N', type=non_negative_int, default=None,
             help=(
-                'Wait for N seconds until server becomes available and goal is completed '
-                '(default waits indefinitely)'
+                'Wait for N seconds until action server becomes available, '
+                'goal is sent, and result is received. '
+                'Also applies to goal cancellation if interrupted. '
+                '(default: waits indefinitely)'
             ))
 
     def main(self, *, args):
@@ -145,7 +147,11 @@ def send_goal(action_name, action_type, goal_values, feedback_callback, timeout=
 
         print('Sending goal:\n     {}'.format(message_to_yaml(goal)))
         goal_future = action_client.send_goal_async(goal, feedback_callback)
-        rclpy.spin_until_future_complete(node, goal_future)
+        rclpy.spin_until_future_complete(node, goal_future, timeout_sec=timeout)
+
+        if not goal_future.done():
+            print(f'Timed out waiting for goal acceptance after {timeout} seconds.')
+            return
 
         goal_handle = goal_future.result()
 
@@ -158,7 +164,11 @@ def _sigint_cancel_handler(sig, frame):
                  GoalStatus.STATUS_EXECUTING == goal_handle.status)):
                 print('Canceling goal...')
                 cancel_future = goal_handle.cancel_goal_async()
-                rclpy.spin_until_future_complete(node, cancel_future)
+                rclpy.spin_until_future_complete(node, cancel_future, timeout_sec=timeout)
+
+                if not cancel_future.done():
+                    raise RuntimeError(
+                        f'Timed out waiting for goal cancellation after {timeout} seconds.')
 
                 cancel_response = cancel_future.result()
 

ros2component/ros2component/api/__init__.py

@@ -68,29 +68,31 @@ def get_registered_component_types():
 ComponentInfo = namedtuple('Component', ('uid', 'name'))
 
 
-def get_components_in_container(*, node, remote_container_node_name):
+def get_components_in_container(*, node, remote_container_node_name, timeout=5.0):
     """
     Get information about the components in a container.
 
     :param node: an `rclpy.Node` instance.
     :param remote_container_node_names: of the container node to inspect.
+    :param timeout: maximum time to wait for response in seconds (default: 5.0).
     :return: a tuple with either a truthy boolean and a list of `ComponentInfo`
         instances containing the unique id and name of each component or a falsy
         boolean and a reason string in case of error.
     """
     return get_components_in_containers(
-        node=node, remote_containers_node_names=[remote_container_node_name]
+        node=node, remote_containers_node_names=[remote_container_node_name], timeout=timeout
     )[remote_container_node_name]
 
 
-def get_components_in_containers(*, node, remote_containers_node_names):
+def get_components_in_containers(*, node, remote_containers_node_names, timeout=5.0):
     """
     Get information about the components in multiple containers.
 
     Get information about the components in a container.
 
     :param node: an `rclpy.Node` instance.
     :param remote_container_node_names: of the container nodes to inspect.
+    :param timeout: maximum time to wait for response in seconds (default: 5.0).
     :return: a dict of tuples, with either a truthy boolean and a list of `ComponentInfo`
         instances containing the unique id and name of each component or a falsy boolean and
         a reason string in case of error, per container node.
@@ -174,7 +176,7 @@ def _resume(to_completion=False):
 
     timer = node.create_timer(timer_period_sec=0.1, callback=resume)
     try:
-        rclpy.spin_until_future_complete(node, future, timeout_sec=5.0)
+        rclpy.spin_until_future_complete(node, future, timeout_sec=timeout)
         if not future.done():
             resume(to_completion=True)
         return dict(future.result())
@@ -193,7 +195,8 @@ def load_component_into_container(
     log_level=None,
     remap_rules=None,
     parameters=None,
-    extra_arguments=None
+    extra_arguments=None,
+    timeout=None
 ):
     """
     Load component into a running container synchronously.
@@ -208,6 +211,7 @@ def load_component_into_container(
     :param remap_rules: remapping rules for the component node, in the 'from:=to' form
     :param parameters: optional parameters for the component node, in the 'name:=value' form
     :param extra_arguments: arguments specific to the container node in the 'name:=value' form
+    :param timeout: maximum time to wait for response in seconds (default: waits indefinitely)
     """
     load_node_client = node.create_client(
         composition_interfaces.srv.LoadNode,
@@ -244,7 +248,11 @@ def load_component_into_container(
                 arg_msg.name = name
                 request.extra_arguments.append(arg_msg)
         future = load_node_client.call_async(request)
-        rclpy.spin_until_future_complete(node, future)
+        rclpy.spin_until_future_complete(node, future, timeout_sec=timeout)
+        if not future.done():
+            raise RuntimeError(
+                'Timed out waiting for load_node response from '
+                f'{remote_container_node_name!r} container (timeout: {timeout}s)')
         response = future.result()
         if not response.success:
             raise RuntimeError('Failed to load component: ' + response.error_message.capitalize())
@@ -253,13 +261,15 @@ def load_component_into_container(
         node.destroy_client(load_node_client)
 
 
-def unload_component_from_container(*, node, remote_container_node_name, component_uids):
+def unload_component_from_container(
+        *, node, remote_container_node_name, component_uids, timeout=None):
     """
     Unload a component from a running container synchronously.
 
     :param node: an `rclpy.Node` instance
     :param remote_container_node_name: of the container node to unload the component from
     :param component_uids: list of unique IDs of the components to be unloaded
+    :param timeout: maximum time to wait for response in seconds (default: waits indefinitely)
     """
     unload_node_client = node.create_client(
         composition_interfaces.srv.UnloadNode,
@@ -274,7 +284,11 @@ def unload_component_from_container(*, node, remote_container_node_name, compone
             request = composition_interfaces.srv.UnloadNode.Request()
             request.unique_id = uid
             future = unload_node_client.call_async(request)
-            rclpy.spin_until_future_complete(node, future)
+            rclpy.spin_until_future_complete(node, future, timeout_sec=timeout)
+            if not future.done():
+                raise RuntimeError(
+                    'Timed out waiting for unload_node response from '
+                    f'{remote_container_node_name!r} container (timeout: {timeout}s)')
             response = future.result()
             yield uid, not response.success, response.error_message
     finally:

ros2component/ros2component/verb/list.py

@@ -36,6 +36,10 @@ def add_arguments(self, parser, cli_name):
         parser.add_argument(
             '--containers-only', action='store_true',
             help='List found containers nodes only')
+        parser.add_argument(
+            '--timeout', metavar='N', type=float, default=5.0,
+            help='Maximum time to wait for listing components in seconds '
+                 '(default: %(default)s)')
 
     def main(self, *, args):
         with NodeStrategy(args) as node:
@@ -47,7 +51,8 @@ def main(self, *, args):
                     return "Unable to find container node '" + args.container_node_name + "'"
                 if not args.containers_only:
                     ok, outcome = get_components_in_container(
-                        node=node, remote_container_node_name=args.container_node_name
+                        node=node, remote_container_node_name=args.container_node_name,
+                        timeout=args.timeout
                     )
                     if not ok:
                         return f'{outcome} when listing components in {args.container_node_name}'
@@ -56,9 +61,12 @@ def main(self, *, args):
                             f'{component.uid}  {component.name}' for component in outcome
                         ], sep='\n')
             else:
-                results = get_components_in_containers(node=node, remote_containers_node_names=[
-                    n.full_name for n in container_node_names
-                ])
+                results = get_components_in_containers(
+                    node=node, remote_containers_node_names=[
+                        n.full_name for n in container_node_names
+                    ],
+                    timeout=args.timeout
+                )
                 for container_node_name, (ok, outcome) in results.items():
                     print(container_node_name)
                     if not args.containers_only:

ros2component/ros2component/verb/load.py

@@ -36,8 +36,11 @@ def add_arguments(self, parser, cli_name):
         add_component_arguments(parser)
         parser.add_argument(
             '-q', '--quiet', action='store_true', default=False,
-            help='Only print component unique IDs and names'
-        )
+            help='Only print component unique IDs and names')
+        parser.add_argument(
+            '--timeout', metavar='N', type=float,
+            help='Maximum time to wait for loading component in seconds '
+                 '(default: waits indefinitely)')
 
     def main(self, *, args):
         with NodeStrategy(args) as node:
@@ -51,7 +54,8 @@ def main(self, *, args):
                 package_name=args.package_name, plugin_name=args.plugin_name,
                 node_name=args.node_name, node_namespace=args.node_namespace,
                 log_level=args.log_level, remap_rules=args.remap_rules,
-                parameters=args.parameters, extra_arguments=args.extra_arguments
+                parameters=args.parameters, extra_arguments=args.extra_arguments,
+                timeout=args.timeout
             )
             if not args.quiet:
                 print("Loaded component {} into '{}' container node as '{}'".format(

ros2component/ros2component/verb/unload.py

@@ -37,8 +37,11 @@ def add_arguments(self, parser, cli_name):
         )
         parser.add_argument(
             '-q', '--quiet', action='store_true', default=False,
-            help='Only print component unique IDs'
-        )
+            help='Only print component unique IDs')
+        parser.add_argument(
+            '--timeout', metavar='N', type=float,
+            help='Maximum time to wait for unloading component in seconds '
+                 '(default: waits indefinitely)')
 
     def main(self, *, args):
         with NodeStrategy(args) as node:
@@ -49,7 +52,7 @@ def main(self, *, args):
                 return "Unable to find container node '" + args.container_node_name + "'"
             for uid, error, reason in unload_component_from_container(
                 node=node, remote_container_node_name=args.container_node_name,
-                component_uids=args.component_uid
+                component_uids=args.component_uid, timeout=args.timeout
             ):
                 if error:
                     return "Failed to unload component {} from '{}' container node\n    {}".format(

ros2lifecycle/ros2lifecycle/api/__init__.py

@@ -43,7 +43,7 @@ def _has_lifecycle(node_name, service_names_and_types):
     return False
 
 
-def call_get_states(*, node, node_names):
+def call_get_states(*, node, node_names, timeout=None):
     clients = {}
     futures = {}
     # create clients
@@ -67,7 +67,10 @@ def call_get_states(*, node, node_names):
 
     # wait for all responses
     for future in futures.values():
-        rclpy.spin_until_future_complete(node, future)
+        rclpy.spin_until_future_complete(node, future, timeout_sec=timeout)
+        if not future.done():
+            raise RuntimeError(
+                f'Timed out waiting for get_state response (timeout: {timeout}s)')
 
     # return current state or exception for each node
     states = {}
@@ -80,15 +83,15 @@ def call_get_states(*, node, node_names):
     return states
 
 
-def call_get_available_transitions(*, node, states):
-    return _call_get_transitions(node, states, 'get_available_transitions')
+def call_get_available_transitions(*, node, states, timeout=None):
+    return _call_get_transitions(node, states, 'get_available_transitions', timeout)
 
 
-def call_get_transition_graph(*, node, states):
-    return _call_get_transitions(node, states, 'get_transition_graph')
+def call_get_transition_graph(*, node, states, timeout=None):
+    return _call_get_transitions(node, states, 'get_transition_graph', timeout)
 
 
-def _call_get_transitions(node, states, service_name):
+def _call_get_transitions(node, states, service_name, timeout=None):
     clients = {}
     futures = {}
     # create clients
@@ -112,7 +115,10 @@ def _call_get_transitions(node, states, service_name):
 
     # wait for all responses
     for future in futures.values():
-        rclpy.spin_until_future_complete(node, future)
+        rclpy.spin_until_future_complete(node, future, timeout_sec=timeout)
+        if not future.done():
+            raise RuntimeError(
+                f'Timed out waiting for {service_name} response (timeout: {timeout}s)')
 
     # return transitions from current state or exception for each node
     transitions = {}
@@ -132,7 +138,7 @@ def _call_get_transitions(node, states, service_name):
     return transitions
 
 
-def call_change_states(*, node, transitions):
+def call_change_states(*, node, transitions, timeout=None):
     clients = {}
     futures = {}
     # create clients
@@ -157,7 +163,10 @@ def call_change_states(*, node, transitions):
 
     # wait for all responses
     for future in futures.values():
-        rclpy.spin_until_future_complete(node, future)
+        rclpy.spin_until_future_complete(node, future, timeout_sec=timeout)
+        if not future.done():
+            raise RuntimeError(
+                f'Timed out waiting for change_state response (timeout: {timeout}s)')
 
     # return success flag or exception for each node
     results = {}

ros2lifecycle/ros2lifecycle/verb/get.py

@@ -37,6 +37,10 @@ def add_arguments(self, parser, cli_name):  # noqa: D102
         parser.add_argument(
             '--include-hidden-nodes', action='store_true',
             help='Consider hidden nodes as well')
+        parser.add_argument(
+            '--timeout', metavar='N', type=float,
+            help='Maximum time to wait for response in seconds '
+                 '(default: waits indefinitely)')
 
     def main(self, *, args):  # noqa: D102
         with NodeStrategy(args) as node:
@@ -55,7 +59,8 @@ def main(self, *, args):  # noqa: D102
         with DirectNode(args) as node:
             # Process and output each node's state immediately upon receipt
             for query_node_name in nodes_to_query:
-                state = call_get_states(node=node, node_names=[query_node_name])
+                state = call_get_states(
+                    node=node, node_names=[query_node_name], timeout=args.timeout)
                 state = state.get(query_node_name)
 
                 if isinstance(state, Exception):

ros2lifecycle/ros2lifecycle/verb/list.py

@@ -40,6 +40,10 @@ def add_arguments(self, parser, cli_name):  # noqa: D102
         parser.add_argument(
             '-a', '--all', action='store_true',
             help='Display all existing transitions')
+        parser.add_argument(
+            '--timeout', metavar='N', type=float,
+            help='Maximum time to wait for response in seconds '
+                 '(default: waits indefinitely)')
 
     def main(self, *, args):  # noqa: D102
         with NodeStrategy(args) as node:
@@ -53,10 +57,10 @@ def main(self, *, args):  # noqa: D102
         with DirectNode(args) as node:
             if args.all:
                 transitions = call_get_transition_graph(
-                    node=node, states={node_name: None})
+                    node=node, states={node_name: None}, timeout=args.timeout)
             else:
                 transitions = call_get_available_transitions(
-                    node=node, states={node_name: None})
+                    node=node, states={node_name: None}, timeout=args.timeout)
             transitions = transitions[node_name]
             if isinstance(transitions, Exception):
                 return 'Exception while calling service of node ' \

ros2lifecycle/ros2lifecycle/verb/set.py

@@ -41,6 +41,10 @@ def add_arguments(self, parser, cli_name):  # noqa: D102
             help='Consider hidden nodes as well')
         parser.add_argument(
             'transition', help='The lifecycle transition')
+        parser.add_argument(
+            '--timeout', metavar='N', type=float,
+            help='Maximum time to wait for response in seconds '
+                 '(default: waits indefinitely)')
 
     def main(self, *, args):  # noqa: D102
         with NodeStrategy(args) as node:
@@ -53,7 +57,7 @@ def main(self, *, args):  # noqa: D102
 
         with DirectNode(args) as node:
             transitions = call_get_available_transitions(
-                node=node, states={node_name: None})
+                node=node, states={node_name: None}, timeout=args.timeout)
             transitions = transitions[node_name]
             if isinstance(transitions, Exception):
                 return 'Exception while calling service of node ' \
@@ -75,7 +79,7 @@ def main(self, *, args):  # noqa: D102
                             for t in transitions)
 
             results = call_change_states(
-                node=node, transitions={node_name: transition})
+                node=node, transitions={node_name: transition}, timeout=args.timeout)
             result = results[node_name]
 
             # output response