ros2 param set /node_name <param1 value1 param2 value2...> support. (#1204)

Signed-off-by: Tomoya Fujita <Tomoya.Fujita@sony.com>

Author: fujitatomoya

ros2param/ros2param/api/__init__.py

@@ -104,6 +104,21 @@ def call_set_parameters(*, node, node_name, parameters):
     return response
 
 
+def call_set_parameters_atomically(*, node, node_name, parameters):
+    client = AsyncParameterClient(node, node_name)
+    ready = client.wait_for_services(timeout_sec=5.0)
+    if not ready:
+        raise RuntimeError('Wait for service timed out waiting for '
+                           f'parameter services for node {node_name}')
+    future = client.set_parameters_atomically(parameters)
+    rclpy.spin_until_future_complete(node, future)
+    response = future.result()
+    if response is None:
+        raise RuntimeError('Exception while calling service of node '
+                           f'{node_name}: {future.exception()}')
+    return response
+
+
 def call_list_parameters(*, node, node_name, prefixes=None, spin_timeout_sec=None):
     client = AsyncParameterClient(node, node_name)
     ready = client.wait_for_services(timeout_sec=5.0)

ros2param/ros2param/verb/set.py

@@ -24,10 +24,28 @@
 from ros2node.api import wait_for_node
 
 from ros2param.api import call_set_parameters
+from ros2param.api import call_set_parameters_atomically
 from ros2param.api import ParameterNameCompleter
 from ros2param.verb import VerbExtension
 
 
+class _NameValueCompleter:
+    """
+    Completer for interleaved name/value pairs.
+
+    Delegates to ParameterNameCompleter for name positions (even index)
+    and returns no completions for value positions (odd index).
+    """
+
+    def __call__(self, prefix, parsed_args, **kwargs):
+        already = getattr(parsed_args, 'params_and_values', None) or []
+        # Even count of already-collected tokens → completing a *name*
+        if len(already) % 2 == 0:
+            return ParameterNameCompleter()(prefix, parsed_args, **kwargs)
+        # Odd count → completing a *value*; no suggestions
+        return []
+
+
 class SetVerb(VerbExtension):
     """Set parameter."""
 
@@ -41,38 +59,80 @@ def add_arguments(self, parser, cli_name):  # noqa: D102
             '--include-hidden-nodes', action='store_true',
             help='Consider hidden nodes as well')
         arg = parser.add_argument(
-            'parameter_name', help='Name of the parameter')
-        arg.completer = ParameterNameCompleter()
+            'params_and_values', nargs='+',
+            metavar='name value',
+            help='Parameter name and value pair(s): name value [name value ...]. '
+                 'Provide one or more name/value pairs to set multiple parameters at once.')
+        arg.completer = _NameValueCompleter()
         parser.add_argument(
-            'value', help='Value of the parameter')
+            '--atomic', action='store_true',
+            help='Set all parameters atomically using the SetParametersAtomically service. '
+                 'Either all parameters are set successfully or none are changed.')
         parser.add_argument(
             '--timeout', metavar='N', type=int, default=1,
             help='Wait for N seconds until node becomes available (default %(default)s sec)')
 
     def main(self, *, args):  # noqa: D102
+        # Validate that parameters were provided as name/value pairs
+        if len(args.params_and_values) % 2 != 0:
+            return (
+                'Parameters must be provided as name/value pairs: '
+                'name value [name value ...]. '
+                f'Got {len(args.params_and_values)} argument(s).'
+            )
+
+        pairs = list(zip(args.params_and_values[::2], args.params_and_values[1::2]))
+        multi_param = len(pairs) > 1
+
         node_name = get_absolute_node_name(args.node_name)
         with NodeStrategy(args) as node:
             if not wait_for_node(node, node_name, args.include_hidden_nodes, args.timeout):
                 return 'Node not found'
 
         with DirectNode(args) as node:
-            parameter = Parameter()
-            parameter.name = args.parameter_name
-            parameter.value = get_parameter_value(string_value=args.value)
-
-            response = call_set_parameters(
-                node=node, node_name=args.node_name, parameters=[parameter])
-
-            # output response
-            assert len(response.results) == 1
-            result = response.results[0]
-            if result.successful:
-                msg = 'Set parameter successful'
-                if result.reason:
-                    msg += ': ' + result.reason
-                print(msg)
+            parameters = []
+            for param_name, param_value_str in pairs:
+                parameter = Parameter()
+                parameter.name = param_name
+                parameter.value = get_parameter_value(string_value=param_value_str)
+                parameters.append(parameter)
+
+            if args.atomic:
+                # Set all parameters in a single atomic transaction
+                response = call_set_parameters_atomically(
+                    node=node, node_name=args.node_name, parameters=parameters)
+
+                result = response.result
+                if result.successful:
+                    msg = 'Set parameters atomically successful'
+                    if result.reason:
+                        msg += ': ' + result.reason
+                    print(msg)
+                else:
+                    msg = 'Setting parameters atomically failed'
+                    if result.reason:
+                        msg += ': ' + result.reason
+                    print(msg, file=sys.stderr)
             else:
-                msg = 'Setting parameter failed'
-                if result.reason:
-                    msg += ': ' + result.reason
-                print(msg, file=sys.stderr)
+                response = call_set_parameters(
+                    node=node, node_name=args.node_name, parameters=parameters)
+
+                # output response
+                assert len(response.results) == len(parameters)
+                for (param_name, _), result in zip(pairs, response.results):
+                    if result.successful:
+                        msg = 'Set parameter successful'
+                        if result.reason:
+                            msg += ': ' + result.reason
+                        if multi_param:
+                            print(f'{param_name}: {msg}')
+                        else:
+                            print(msg)
+                    else:
+                        msg = 'Setting parameter failed'
+                        if result.reason:
+                            msg += ': ' + result.reason
+                        if multi_param:
+                            print(f'{param_name}: {msg}', file=sys.stderr)
+                        else:
+                            print(msg, file=sys.stderr)