Support container in frontend (#235)

Signed-off-by: Kenji Miyake <kenji.miyake@tier4.jp>

launch_ros/launch_ros/actions/composable_node_container.py

@@ -18,6 +18,9 @@
 from typing import Optional
 
 from launch.action import Action
+from launch.frontend import Entity
+from launch.frontend import expose_action
+from launch.frontend import Parser
 from launch.launch_context import LaunchContext
 from launch.some_substitutions_type import SomeSubstitutionsType
 
@@ -26,6 +29,7 @@
 from ..descriptions import ComposableNode
 
 
+@expose_action('node_container')
 class ComposableNodeContainer(Node):
  """Action that executes a container ROS node for composable ROS nodes."""
 
@@ -51,6 +55,22 @@ def __init__(
  super().__init__(name=name, namespace=namespace, **kwargs)
  self.__composable_node_descriptions = composable_node_descriptions
 
+ @classmethod
+ def parse(cls, entity: Entity, parser: Parser):
+ """Parse node_container."""
+ _, kwargs = super().parse(entity, parser)
+
+ composable_nodes = entity.get_attr(
+ 'composable_node', data_type=List[Entity], optional=True)
+ if composable_nodes is not None:
+ kwargs['composable_node_descriptions'] = []
+ for entity in composable_nodes:
+ composable_node_cls, composable_node_kwargs = ComposableNode.parse(parser, entity)
+ kwargs['composable_node_descriptions'].append(
+ composable_node_cls(**composable_node_kwargs))
+
+ return cls, kwargs
+
  def execute(self, context: LaunchContext) -> Optional[List[Action]]:
  """
  Execute the action.

launch_ros/launch_ros/actions/load_composable_nodes.py

@@ -24,6 +24,9 @@
 import composition_interfaces.srv
 
 from launch.action import Action
+from launch.frontend import Entity
+from launch.frontend import expose_action
+from launch.frontend import Parser
 from launch.launch_context import LaunchContext
 import launch.logging
 from launch.some_substitutions_type import SomeSubstitutionsType
@@ -46,6 +49,7 @@
 from ..utilities.normalize_parameters import normalize_parameter_dict
 
 
+@expose_action('load_composable_node')
 class LoadComposableNodes(Action):
  """Action that loads composable ROS nodes into a running container."""
 
@@ -82,6 +86,23 @@ def __init__(
  self.__final_target_container_name = None # type: Optional[Text]
  self.__logger = launch.logging.get_logger(__name__)
 
+ @classmethod
+ def parse(cls, entity: Entity, parser: Parser):
+ """Parse load_composable_node."""
+ _, kwargs = super().parse(entity, parser)
+
+ kwargs['target_container'] = parser.parse_substitution(
+ entity.get_attr('target', data_type=str))
+
+ composable_nodes = entity.get_attr('composable_node', data_type=List[Entity])
+ kwargs['composable_node_descriptions'] = []
+ for entity in composable_nodes:
+ composable_node_cls, composable_node_kwargs = ComposableNode.parse(parser, entity)
+ kwargs['composable_node_descriptions'].append(
+ composable_node_cls(**composable_node_kwargs))
+
+ return cls, kwargs
+
  def _load_node(
  self,
  request: composition_interfaces.srv.LoadNode.Request,

launch_ros/launch_ros/descriptions/composable_node.py

@@ -17,6 +17,8 @@
 from typing import List
 from typing import Optional
 
+from launch.frontend import Entity
+from launch.frontend import Parser
 from launch.some_substitutions_type import SomeSubstitutionsType
 from launch.substitution import Substitution
 # from launch.utilities import ensure_argument_type
@@ -76,6 +78,52 @@ def __init__(
  if extra_arguments:
  self.__extra_arguments = normalize_parameters(extra_arguments)
 
+ @classmethod
+ def parse(cls, parser: Parser, entity: Entity):
+ """Parse composable_node."""
+ from launch_ros.actions import Node
+ kwargs = {}
+
+ kwargs['package'] = parser.parse_substitution(entity.get_attr('pkg'))
+ kwargs['plugin'] = parser.parse_substitution(entity.get_attr('plugin'))
+ kwargs['name'] = parser.parse_substitution(entity.get_attr('name'))
+
+ namespace = entity.get_attr('namespace', optional=True)
+ if namespace is not None:
+ kwargs['namespace'] = parser.parse_substitution(namespace)
+
+ parameters = entity.get_attr('param', data_type=List[Entity], optional=True)
+ if parameters is not None:
+ kwargs['parameters'] = Node.parse_nested_parameters(parameters, parser)
+
+ remappings = entity.get_attr('remap', data_type=List[Entity], optional=True)
+ if remappings is not None:
+ kwargs['remappings'] = [
+ (
+ parser.parse_substitution(remap.get_attr('from')),
+ parser.parse_substitution(remap.get_attr('to'))
+ ) for remap in remappings
+ ]
+
+ for remap in remappings:
+ remap.assert_entity_completely_parsed()
+
+ extra_arguments = entity.get_attr('extra_arg', data_type=List[Entity], optional=True)
+ if extra_arguments is not None:
+ kwargs['extra_arguments'] = [
+ {
+ tuple(parser.parse_substitution(extra_arg.get_attr('name'))):
+ parser.parse_substitution(extra_arg.get_attr('value'))
+ } for extra_arg in extra_arguments
+ ]
+
+ for extra_arg in extra_arguments:
+ extra_arg.assert_entity_completely_parsed()
+
+ entity.assert_entity_completely_parsed()
+
+ return cls, kwargs
+
  @property
  def package(self) -> List[Substitution]:
  """Get node package name as a sequence of substitutions to be performed."""

test_launch_ros/test/test_launch_ros/frontend/test_component_container.py

@@ -0,0 +1,161 @@
+# Copyright 2019 Open Source Robotics Foundation, Inc.
+# Copyright 2020 Open Avatar Inc.
+#
+# 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.
+
+import asyncio
+import io
+import textwrap
+
+from launch import LaunchService
+from launch.frontend import Parser
+from launch.utilities import perform_substitutions
+from launch_ros.utilities import evaluate_parameters
+import osrf_pycommon.process_utils
+
+
+def test_launch_component_container_yaml():
+ yaml_file = textwrap.dedent(
+ r"""
+ launch:
+ - node_container:
+ pkg: rclcpp_components
+ exec: component_container
+ name: my_container
+ namespace: ''
+ args: 'test_args'
+ composable_node:
+ - pkg: composition
+ plugin: composition::Talker
+ name: talker
+ namespace: test_namespace
+ remap:
+ - from: chatter
+ to: /remap/chatter
+ param:
+ - name: use_sim_time
+ value: true
+ extra_arg:
+ - name: use_intra_process_comms
+ value: 'true'
+
+ - load_composable_node:
+ target: my_container
+ composable_node:
+ - pkg: composition
+ plugin: composition::Listener
+ name: listener
+ namespace: test_namespace
+ remap:
+ - from: chatter
+ to: /remap/chatter
+ param:
+ - name: use_sim_time
+ value: true
+ extra_arg:
+ - name: use_intra_process_comms
+ value: 'true'
+ """
+ )
+ with io.StringIO(yaml_file) as f:
+ check_launch_component_container(f)
+
+
+def test_launch_component_container_xml():
+ xml_file = textwrap.dedent(
+ r"""
+ <launch>
+ <node_container pkg="rclcpp_components" exec="component_container" name="my_container" namespace="" args="test_args">
+ <composable_node pkg="composition" plugin="composition::Talker" name="talker" namespace="test_namespace">
+ <remap from="chatter" to="/remap/chatter" />
+ <param name="use_sim_time" value="true"/>
+ <extra_arg name="use_intra_process_comms" value="true"/>
+ </composable_node>
+ </node_container>
+
+ <load_composable_node target="my_container">
+ <composable_node pkg="composition" plugin="composition::Listener" name="listener" namespace="test_namespace">
+ <remap from="chatter" to="/remap/chatter" />
+ <param name="use_sim_time" value="true"/>
+ <extra_arg name="use_intra_process_comms" value="true"/>
+ </composable_node>
+ </load_composable_node>
+ </launch>
+ """ # noqa: E501
+ )
+ with io.StringIO(xml_file) as f:
+ check_launch_component_container(f)
+
+
+def check_launch_component_container(file):
+ root_entity, parser = Parser.load(file)
+ ld = parser.parse_description(root_entity)
+ ls = LaunchService()
+ ls.include_launch_description(ld)
+
+ loop = osrf_pycommon.process_utils.get_loop()
+ launch_task = loop.create_task(ls.run_async())
+
+ node_container, load_composable_node = ld.describe_sub_entities()
+ talker = node_container._ComposableNodeContainer__composable_node_descriptions[0]
+ listener = load_composable_node._LoadComposableNodes__composable_node_descriptions[0]
+
+ def perform(substitution):
+ return perform_substitutions(ls.context, substitution)
+
+ # Check container params
+ assert perform(node_container._Node__package) == 'rclcpp_components'
+ assert perform(node_container._Node__node_executable) == 'component_container'
+ assert perform(node_container._Node__node_name) == 'my_container'
+ assert perform(node_container._Node__node_namespace) == ''
+ assert perform(node_container._Node__arguments[0]) == 'test_args'
+
+ assert perform(load_composable_node._LoadComposableNodes__target_container) == 'my_container'
+
+ # Check node parameters
+ talker_remappings = list(talker._ComposableNode__remappings)
+ listener_remappings = list(listener._ComposableNode__remappings)
+
+ talker_params = evaluate_parameters(ls.context, talker._ComposableNode__parameters)
+ listener_params = evaluate_parameters(ls.context, listener._ComposableNode__parameters)
+
+ talker_extra_args = evaluate_parameters(ls.context, talker._ComposableNode__extra_arguments)
+ listener_extra_args = evaluate_parameters(
+ ls.context, listener._ComposableNode__extra_arguments)
+
+ assert perform(talker._ComposableNode__package) == 'composition'
+ assert perform(talker._ComposableNode__node_plugin) == 'composition::Talker'
+ assert perform(talker._ComposableNode__node_name) == 'talker'
+ assert perform(talker._ComposableNode__node_namespace) == 'test_namespace'
+ assert (perform(talker_remappings[0][0]),
+ perform(talker_remappings[0][1])) == ('chatter', '/remap/chatter')
+ assert talker_params[0]['use_sim_time'] is True
+
+ assert perform(listener._ComposableNode__package) == 'composition'
+ assert perform(listener._ComposableNode__node_plugin) == 'composition::Listener'
+ assert perform(listener._ComposableNode__node_name) == 'listener'
+ assert perform(listener._ComposableNode__node_namespace) == 'test_namespace'
+ assert (perform(listener_remappings[0][0]),
+ perform(listener_remappings[0][1])) == ('chatter', '/remap/chatter')
+ assert listener_params[0]['use_sim_time'] is True
+
+ # Check extra arguments
+ assert talker_extra_args[0]['use_intra_process_comms'] is True
+ assert listener_extra_args[0]['use_intra_process_comms'] is True
+
+ timeout_sec = 5
+ loop.run_until_complete(asyncio.sleep(timeout_sec))
+ if not launch_task.done():
+ loop.create_task(ls.shutdown())
+ loop.run_until_complete(launch_task)
+ assert 0 == launch_task.result()