ros2doctor: add node and parameter info to report

Add NodeCheck/NodeReport and ParameterCheck/ParameterReport so the
ros2doctor report shows active nodes and their parameters.

- Add `ros2doctor/api/node.py` (node discovery, NodeCheck, NodeReport)
- Add `ros2doctor/api/parameter.py` (parameter discovery, ParameterCheck, ParameterReport)
- Update  entry points in `ros2doctor/setup.py`:
  - `ros2doctor.checks: NodeCheck` and `ParameterCheck`
  - `ros2doctor.report: NodeReport` and `ParameterReport`

Why:
This enhancement provides valuable insights into the active nodes and their parameters
within a ROS 2 system. By including this information in the `ros2 doctor` report
sections in the `ros2 doctor --report` output, giving users better visibility into
the runtime ROS 2 system configuration.

Fixes: #1090

Signed-off-by: BhuvanB404 <bhuvanb404@gmail.com>
Signed-off-by: BhuvanB404 <bhuvanb1408@gmail.com>

Author: BhuvanB404

ros2doctor/ros2doctor/api/node.py

@@ -0,0 +1,75 @@
+# Copyright 2025 Open Source Robotics Foundation, 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.
+
+
+from collections import defaultdict
+
+from ros2cli.node.strategy import NodeStrategy
+from ros2node.api import get_node_names
+from ros2doctor.api import DoctorCheck
+from ros2doctor.api import DoctorReport
+from ros2doctor.api import Report
+from ros2doctor.api import Result
+from ros2doctor.api.format import doctor_warn
+
+
+
+def has_duplicates(values):
+    """Find out if there are any exact duplicates in a list of strings."""
+    return len(set(values)) < len(values)
+
+
+class NodeCheck(DoctorCheck):
+    """Check for duplicate node names."""
+
+    def category(self):
+        return 'node'
+
+    def check(self):
+        result = Result()
+        with NodeStrategy(None) as node:
+            node_list = get_node_names(node=node, include_hidden_nodes=True)
+            node_names = [n.full_name for n in node_list]
+            if has_duplicates(node_names):
+            
+                name_counts = defaultdict(int)
+                for name in node_names:
+                    name_counts[name] += 1
+                
+                duplicates = [name for name, count in name_counts.items() if count > 1]
+                for duplicate in duplicates:
+                    doctor_warn(f'Duplicate node name: {duplicate}')
+                    result.add_warning()
+        return result
+
+
+class NodeReport(DoctorReport):
+    """Report node related information."""
+
+    def category(self):
+        return 'node'
+
+    def report(self):
+        report = Report('NODE LIST')
+        with NodeStrategy(None) as node:
+            node_list = get_node_names(node=node, include_hidden_nodes=True)
+            node_names = [n.full_name for n in node_list]
+            if not node_names:
+                report.add_to_report('node count', 0)
+                report.add_to_report('node', 'none')
+            else:
+                report.add_to_report('node count', len(node_names))
+                for node_name in sorted(node_names):
+                    report.add_to_report('node', node_name)
+        return report

ros2doctor/ros2doctor/api/parameter.py

@@ -0,0 +1,120 @@
+# Copyright 2025 Open Source Robotics Foundation, 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 rclpy
+from rcl_interfaces.srv import ListParameters
+from ros2cli.node.direct import DirectNode
+from ros2cli.node.strategy import NodeStrategy
+from ros2doctor.api import DoctorCheck
+from ros2doctor.api import DoctorReport
+from ros2doctor.api import Report
+from ros2doctor.api import Result
+from ros2doctor.api.format import doctor_warn
+
+
+
+def call_list_parameters(node, node_name, namespace='/'):
+    """Call the list_parameters service for a specific node."""
+    try:
+        """ Create service name  and client list for the target node and list_parameters service """
+        service_name = f"{namespace.rstrip('/')}/{node_name}/list_parameters"
+        if service_name.startswith('//'):
+            service_name = service_name[1:]
+        
+        client = node.create_client(ListParameters, service_name)
+        
+        if not client.wait_for_service(timeout_sec=1.0):
+            return None
+            
+        request = ListParameters.Request()
+        future = client.call_async(request)
+        
+        """  Spinning for acess active response """
+        rclpy.spin_until_future_complete(node, future, timeout_sec=2.0)
+        
+        if future.done():
+            response = future.result()
+            node.destroy_client(client)
+            return response
+        else:
+            node.destroy_client(client)
+            return None
+            
+    except Exception:
+        return None
+
+
+class ParameterCheck(DoctorCheck):
+    """Check for nodes without parameter services."""
+
+    def category(self):
+        return 'parameter'
+
+    def check(self):
+        result = Result()
+        with NodeStrategy(None) as node:
+            try:
+                node_names_and_namespaces = node.get_node_names_and_namespaces()
+            except Exception:
+                node_names_and_namespaces = []
+            with DirectNode(None) as param_node:
+                for node_name, namespace in node_names_and_namespaces:
+                    response = call_list_parameters(param_node.node, node_name, namespace)
+                    if response is None:
+                        full_name = f"{namespace.rstrip('/')}/{node_name}"
+                        doctor_warn(f'Node {full_name} has no parameter services.')
+                        result.add_warning()
+        return result
+
+
+class ParameterReport(DoctorReport):
+    """Report parameter related information."""
+
+    def category(self):
+        return 'parameter'
+
+    def report(self):
+        report = Report('PARAMETER LIST')
+        with NodeStrategy(None) as node:
+            try:
+                node_names_and_namespaces = node.get_node_names_and_namespaces()
+            except Exception:
+                node_names_and_namespaces = []
+            if not node_names_and_namespaces:
+                report.add_to_report('total nodes checked', 0)
+                report.add_to_report('total parameter count', 0)
+                report.add_to_report('parameter', 'none')
+                return report
+
+            total_param_count = 0
+            nodes_checked = 0
+
+            with DirectNode(None) as param_node:
+                for node_name, namespace in sorted(node_names_and_namespaces):
+                    nodes_checked += 1
+                    response = call_list_parameters(param_node.node, node_name, namespace)
+                    if response and hasattr(response, 'result') and response.result:
+                        param_names = response.result.names if hasattr(response.result, 'names') else []
+                        if param_names:
+                            total_param_count += len(param_names)
+                            full_name = f"{namespace.rstrip('/')}/{node_name}"
+                           
+                            report.add_to_report('node', full_name)
+                            for param_name in sorted(param_names):
+                                report.add_to_report('parameter', param_name)
+
+            report.add_to_report('total nodes checked', nodes_checked)
+            report.add_to_report('total parameter count', total_param_count)
+        return report

ros2doctor/setup.py

@@ -47,6 +47,8 @@
             'TopicCheck = ros2doctor.api.topic:TopicCheck',
             'QoSCompatibilityCheck = ros2doctor.api.qos_compatibility:QoSCompatibilityCheck',
             'PackageCheck = ros2doctor.api.package:PackageCheck',
+            'NodeCheck = ros2doctor.api.node:NodeCheck',
+            'ParameterCheck = ros2doctor.api.parameter:ParameterCheck',
         ],
         'ros2doctor.report': [
             'PlatformReport = ros2doctor.api.platform:PlatformReport',
@@ -58,7 +60,9 @@
             'ActionReport = ros2doctor.api.action:ActionReport',
             'QoSCompatibilityReport = ros2doctor.api.qos_compatibility:QoSCompatibilityReport',
             'PackageReport = ros2doctor.api.package:PackageReport',
-            'EnvironmentReport = ros2doctor.api.environment:EnvironmentReport'
+            'EnvironmentReport = ros2doctor.api.environment:EnvironmentReport',
+            'NodeReport = ros2doctor.api.node:NodeReport',
+            'ParameterReport = ros2doctor.api.parameter:ParameterReport'
         ],
         'ros2cli.extension_point': [
             'ros2doctor.verb = ros2doctor.verb:VerbExtension',