Remove 'node_' prefix from members and arguments.

Distro A, OPSEC #4584. You may have additional rights; please see https://rosmilitary.org/faq/?category=ros-2-license

Signed-off-by: matthew.lanting <[email protected]>

Author: mlanting

launch_ros/launch_ros/actions/lifecycle_node.py

@@ -123,7 +123,7 @@ def unblock(future):
             self.__logger.error(
                 "Failed to make transition '{}' for LifecycleNode '{}'".format(
                     ChangeState.valid_transitions[request.transition.id],
-                    self.node_name,
+                    self.name,
                 )
             )
 
@@ -142,20 +142,20 @@ def execute(self, context: launch.LaunchContext) -> Optional[List[Action]]:
 
         Delegated to :meth:`launch.actions.ExecuteProcess.execute`.
         """
-        self.prepare(context)  # ensure self.node_name is expanded
-        if '<node_name_unspecified>' in self.node_name:
-            raise RuntimeError('node_name unexpectedly incomplete for lifecycle node')
+        self.prepare(context)  # ensure self.name is expanded
+        if '<node_name_unspecified>' in self.name:
+            raise RuntimeError('name unexpectedly incomplete for lifecycle node')
         node = get_ros_node(context)
         # Create a subscription to monitor the state changes of the subprocess.
         self.__rclpy_subscription = node.create_subscription(
             lifecycle_msgs.msg.TransitionEvent,
-            '{}/transition_event'.format(self.node_name),
+            '{}/transition_event'.format(self.name),
             functools.partial(self._on_transition_event, context),
             10)
         # Create a service client to change state on demand.
         self.__rclpy_change_state_client = node.create_client(
             lifecycle_msgs.srv.ChangeState,
-            '{}/change_state'.format(self.node_name))
+            '{}/change_state'.format(self.name))
         # Register an event handler to change states on a ChangeState lifecycle event.
         context.register_event_handler(launch.EventHandler(
             matcher=lambda event: isinstance(event, ChangeState),

launch_ros/launch_ros/actions/load_composable_nodes.py

@@ -210,7 +210,7 @@ def execute(
         # resolve target container node name
 
         if is_a_subclass(self.__target_container, ComposableNodeContainer):
-            self.__final_target_container_name = self.__target_container.node_name
+            self.__final_target_container_name = self.__target_container.name
         elif isinstance(self.__target_container, SomeSubstitutionsType_types_tuple):
             subs = normalize_to_list_of_substitutions(self.__target_container)
             self.__final_target_container_name = perform_substitutions(
@@ -253,11 +253,11 @@ def get_composable_node_load_request(
     request.plugin_name = perform_substitutions(
         context, composable_node_description.node_plugin
     )
-    if composable_node_description.node_name is not None:
+    if composable_node_description.name is not None:
         request.node_name = perform_substitutions(
-            context, composable_node_description.node_name
+            context, composable_node_description.name
         )
-    expanded_ns = composable_node_description.node_namespace
+    expanded_ns = composable_node_description.namespace
     if expanded_ns is not None:
         expanded_ns = perform_substitutions(context, expanded_ns)
     base_ns = context.launch_configurations.get('ros_namespace', None)

launch_ros/launch_ros/actions/node.py

@@ -127,7 +127,7 @@ def __init__(
         :param: ros_arguments list of ROS arguments for the node
         :param: arguments list of extra arguments for the node
         """
-        self.__node_desc = NodeDescription(node_name=name, node_namespace=namespace,
+        self.__node_desc = NodeDescription(name=name, namespace=namespace,
                                            parameters=parameters, remappings=remappings)
         executable_keywords = inspect.signature(Executable).parameters.keys()
         ros_exec_kwargs = {key: val for key, val in kwargs.items() if key in executable_keywords}
@@ -136,8 +136,8 @@ def __init__(
                                         nodes=[self.__node_desc], **ros_exec_kwargs)
         super().__init__(process_description=self.__ros_exec, **kwargs)
 
-    def is_node_name_fully_specified(self):
-        return self.__node_desc.is_node_name_fully_specified()
+    def is_name_fully_specified(self):
+        return self.__node_desc.is_name_fully_specified()
 
     @staticmethod
     def parse_nested_parameters(params, parser):
@@ -217,12 +217,12 @@ def parse(cls, entity: Entity, parser: Parser):
         ros_args = entity.get_attr('ros_args', optional=True)
         if ros_args is not None:
             kwargs['ros_arguments'] = ExecuteProcess._parse_cmdline(ros_args, parser)
-        node_name = entity.get_attr('node-name', optional=True)
-        if node_name is not None:
-            kwargs['node_name'] = parser.parse_substitution(node_name)
-        node_name = entity.get_attr('name', optional=True)
-        if node_name is not None:
-            kwargs['name'] = parser.parse_substitution(node_name)
+        name = entity.get_attr('node-name', optional=True)
+        if name is not None:
+            kwargs['name'] = parser.parse_substitution(name)
+        name = entity.get_attr('name', optional=True)
+        if name is not None:
+            kwargs['name'] = parser.parse_substitution(name)
         exec_name = entity.get_attr('exec_name', optional=True)
         if exec_name is not None:
             kwargs['exec_name'] = parser.parse_substitution(exec_name)
@@ -250,29 +250,29 @@ def parse(cls, entity: Entity, parser: Parser):
         return cls, kwargs
 
     @property
-    def node_package(self):
-        """Getter for node_package."""
+    def package(self):
+        """Getter for package."""
         return self.__ros_exec.package
 
     @property
-    def node_executable(self):
-        """Getter for node_executable."""
+    def executable(self):
+        """Getter for executable."""
         return self.__ros_exec.executable
 
     @property
-    def node_name(self):
-        """Getter for node_name."""
-        return self.__node_desc.node_name
+    def name(self):
+        """Getter for name."""
+        return self.__node_desc.name
 
     @property
     def ros_exec(self):
         """Getter for ros_exec."""
         return self.__ros_exec
 
     @property
-    def expanded_node_namespace(self):
-        """Getter for expanded_node_namespace."""
-        return self.__node_desc.expanded_node_namespace
+    def expanded_namespace(self):
+        """Getter for expanded_namespace."""
+        return self.__node_desc.expanded_namespace
 
     @property
     def expanded_remapping_rules(self):

launch_ros/launch_ros/descriptions/composable_node.py

@@ -58,13 +58,13 @@ def __init__(
         self.__package = normalize_to_list_of_substitutions(package)
         self.__node_plugin = normalize_to_list_of_substitutions(plugin)
 
-        self.__node_name = None  # type: Optional[List[Substitution]]
+        self.__name = None  # type: Optional[List[Substitution]]
         if name is not None:
-            self.__node_name = normalize_to_list_of_substitutions(name)
+            self.__name = normalize_to_list_of_substitutions(name)
 
-        self.__node_namespace = None  # type: Optional[List[Substitution]]
+        self.__namespace = None  # type: Optional[List[Substitution]]
         if namespace is not None:
-            self.__node_namespace = normalize_to_list_of_substitutions(namespace)
+            self.__namespace = normalize_to_list_of_substitutions(namespace)
 
         self.__parameters = None  # type: Optional[Parameters]
         if parameters is not None:
@@ -135,14 +135,14 @@ def node_plugin(self) -> List[Substitution]:
         return self.__node_plugin
 
     @property
-    def node_name(self) -> Optional[List[Substitution]]:
+    def name(self) -> Optional[List[Substitution]]:
         """Get node name as a sequence of substitutions to be performed."""
-        return self.__node_name
+        return self.__name
 
     @property
-    def node_namespace(self) -> Optional[List[Substitution]]:
+    def namespace(self) -> Optional[List[Substitution]]:
         """Get node namespace as a sequence of substitutions to be performed."""
-        return self.__node_namespace
+        return self.__namespace
 
     @property
     def parameters(self) -> Optional[Parameters]: