Changed integrate_database name to just mocha

Author: fcladera

mocha_core/CMakeLists.txt

@@ -39,7 +39,7 @@ install(
 
 # Install executables as scripts
 install(PROGRAMS
-  mocha_core/integrate_database.py
+  mocha_core/mocha.py
   mocha_core/database_server.py
   mocha_core/synchronize_channel.py
   mocha_core/zmq_comm_node.py

mocha_core/launch/database_translators_publishers.launch.py

@@ -11,14 +11,14 @@ def generate_launch_description():
     """
     Launch database, translator, and topic publisher nodes for MOCHA system
     """
-    
+
     # Declare launch arguments
     robot_name_arg = DeclareLaunchArgument(
         'robot_name',
         default_value='charon',
         description='Name of the robot'
     )
-    
+
     robot_configs_arg = DeclareLaunchArgument(
         'robot_configs',
         default_value=PathJoinSubstitution([
@@ -27,16 +27,16 @@ def generate_launch_description():
         ]),
         description='Path to robot configuration file'
     )
-    
+
     topic_configs_arg = DeclareLaunchArgument(
-        'topic_configs', 
+        'topic_configs',
         default_value=PathJoinSubstitution([
             FindPackageShare('mocha_core'),
             'config', 'topic_configs.yaml'
         ]),
         description='Path to topic configuration file'
     )
-    
+
     radio_configs_arg = DeclareLaunchArgument(
         'radio_configs',
         default_value=PathJoinSubstitution([
@@ -45,18 +45,18 @@ def generate_launch_description():
         ]),
         description='Path to radio configuration file'
     )
-    
+
     # Get launch configurations
     robot_name = LaunchConfiguration('robot_name')
     robot_configs = LaunchConfiguration('robot_configs')
     topic_configs = LaunchConfiguration('topic_configs')
     radio_configs = LaunchConfiguration('radio_configs')
-    
+
     # Define nodes
-    integrate_database_node = Node(
+    mocha_node = Node(
         package='mocha_core',
-        executable='integrate_database.py',
-        name='integrate_database',
+        executable='mocha.py',
+        name='mocha',
         output='screen',
         parameters=[{
             'robot_name': robot_name,
@@ -66,7 +66,7 @@ def generate_launch_description():
             'rssi_threshold': 35
         }]
     )
-    
+
     translator_node = Node(
         package='mocha_core',
         executable='translator.py',
@@ -78,7 +78,7 @@ def generate_launch_description():
             'topic_configs': topic_configs
         }]
     )
-    
+
     topic_publisher_node = Node(
         package='mocha_core',
         executable='topic_publisher.py',
@@ -90,13 +90,13 @@ def generate_launch_description():
             'topic_configs': topic_configs
         }]
     )
-    
+
     return LaunchDescription([
         robot_name_arg,
         robot_configs_arg,
         topic_configs_arg,
         radio_configs_arg,
-        integrate_database_node,
+        mocha_node,
         translator_node,
         topic_publisher_node
-    ])
+    ])

mocha_core/mocha_core/integrate_database.py renamed to mocha_core/mocha_core/mocha.py

@@ -35,16 +35,16 @@ def ping(host):
         return False
 
 
-class IntegrateDatabase(Node):
+class Mocha(Node):
     def __init__(self):
-        super().__init__("integrate_database")
+        super().__init__("mocha_setver")
 
         # Handle shutdown signal
         self.shutdownTriggered = threading.Event()
         self.shutdownTriggered.clear()
 
         def signal_handler(sig, frame):
-            self.logger.warning(f"{self.this_robot} - Integrate - Got SIGINT. Triggering shutdown.")
+            self.logger.warning(f"{self.this_robot} - MOCHA Server - Got SIGINT. Triggering shutdown.")
             self.shutdown("Killed by user")
         signal.signal(signal.SIGINT, signal_handler)
 
@@ -63,13 +63,13 @@ def signal_handler(sig, frame):
         self.rssi_threshold = self.get_parameter("rssi_threshold").get_parameter_value().integer_value
 
         if len(self.this_robot) == 0:
-            self.logger.error(f"{self.this_robot} - Integrate - Empty robot name")
+            self.logger.error(f"{self.this_robot} - MOCHA Server - Empty robot name")
             raise ValueError("Empty robot name")
 
-        self.logger.info(f"{self.this_robot} - Integrate - " +
+        self.logger.info(f"{self.this_robot} - MOCHA Server - " +
                         f"RSSI threshold: {self.rssi_threshold}")
         self.client_timeout = self.get_parameter("client_timeout").get_parameter_value().double_value
-        self.logger.info(f"{self.this_robot} - Integrate - " +
+        self.logger.info(f"{self.this_robot} - MOCHA Server - " +
                         f"Client timeout: {self.client_timeout}")
 
         # Load and check robot configs
@@ -78,10 +78,10 @@ def signal_handler(sig, frame):
             with open(self.robot_configs_file, "r") as f:
                 self.robot_configs = yaml.load(f, Loader=yaml.FullLoader)
         except Exception as e:
-            self.logger.error(f"{self.this_robot} - Integrate - robot_configs file")
+            self.logger.error(f"{self.this_robot} - MOCHA Server - robot_configs file")
             raise e
         if self.this_robot not in self.robot_configs.keys():
-            self.logger.error(f"{self.this_robot} - Integrate - robot_configs file")
+            self.logger.error(f"{self.this_robot} - MOCHA Server - robot_configs file")
             raise ValueError("Robot not in config file")
 
         # Load and check radio configs
@@ -90,11 +90,11 @@ def signal_handler(sig, frame):
             with open(self.radio_configs_file, "r") as f:
                 self.radio_configs = yaml.load(f, Loader=yaml.FullLoader)
         except Exception as e:
-            self.logger.error(f"{self.this_robot} - Integrate - radio_configs file")
+            self.logger.error(f"{self.this_robot} - MOCHA Server - radio_configs file")
             raise e
         self.radio = self.robot_configs[self.this_robot]["using-radio"]
         if self.radio not in self.radio_configs.keys():
-            self.logger.error(f"{self.this_robot} - Integrate - radio_configs file")
+            self.logger.error(f"{self.this_robot} - MOCHA Server - radio_configs file")
             raise ValueError("Radio {self.radio} not in config file")
 
         # Load and check topic configs
@@ -103,17 +103,17 @@ def signal_handler(sig, frame):
             with open(self.topic_configs_file, "r") as f:
                 self.topic_configs = yaml.load(f, Loader=yaml.FullLoader)
         except Exception as e:
-            self.logger.error(f"{self.this_robot} - Integrate - topics_configs file")
+            self.logger.error(f"{self.this_robot} - MOCHA Server - topics_configs file")
             raise e
         self_type = self.robot_configs[self.this_robot]["node-type"]
         if self_type not in self.topic_configs.keys():
-            self.logger.error(f"{self.this_robot} - Integrate - topics_configs file")
+            self.logger.error(f"{self.this_robot} - MOCHA Server - topics_configs file")
             raise ValueError("Node type not in config file")
 
         # Check that we can ping the radios
         ip = self.robot_configs[self.this_robot]["IP-address"]
         if not ping(ip):
-            self.logger.error(f"{self.this_robot} - Integrate - " +
+            self.logger.error(f"{self.this_robot} - MOCHA Server - " +
                              f"Cannot ping self {ip}. Is the radio on?")
             raise ValueError("Cannot ping self")
 
@@ -124,7 +124,7 @@ def signal_handler(sig, frame):
 
         self.num_robot_in_comm = 0
 
-        self.logger.info(f"{self.this_robot} - Integrate - " +
+        self.logger.info(f"{self.this_robot} - MOCHA Server - " +
                         "Created all communication channels!")
 
         # Start comm channels with other robots
@@ -134,7 +134,7 @@ def signal_handler(sig, frame):
         for other_robot in self.other_robots:
             if other_robot not in self.robot_configs[self.this_robot]["clients"]:
                 self.logger.warning(
-                    f"{self.this_robot} - Integrate - "+
+                    f"{self.this_robot} - MOCHA Server - "+
                     f"Skipping channel {self.this_robot}->{other_robot} " +
                     "as it is not in the graph of this robot"
                 )
@@ -167,16 +167,16 @@ def shutdown(self, reason):
         self.shutdownTriggered.set()
 
         assert isinstance(reason, str)
-        self.logger.error(f"{self.this_robot} - Integrate - " + reason)
+        self.logger.error(f"{self.this_robot} - MOCHA Server - " + reason)
         # Shutting down communication channels
         if hasattr(self, 'all_channels') and len(self.all_channels) != 0:
             for channel in self.all_channels:
                 channel.stop()
-            self.logger.warning(f"{self.this_robot} - Integrate - " + "Killed Channels")
+            self.logger.warning(f"{self.this_robot} - MOCHA Server - " + "Killed Channels")
             # Wait for all the channels to be gone. This needs to be slightly
             # larger than RECV_TIMEOUT
             time.sleep(3.5)
-        self.logger.warning(f"{self.this_robot} - Integrate - " + "Shutdown complete")
+        self.logger.warning(f"{self.this_robot} - MOCHA Server - " + "Shutdown complete")
 
     def rssi_cb(self, data, comm_node):
         rssi = data.data
@@ -195,30 +195,30 @@ def main(args=None):
 
     # Start the node
     try:
-        integrate_db = IntegrateDatabase()
+        mocha = Mocha()
     except Exception as e:
         print(f"Node initialization failed: {e}")
         rclpy.shutdown()
         return
 
     # Load mtexecutor
     mtexecutor = MultiThreadedExecutor(num_threads=4)
-    mtexecutor.add_node(integrate_db)
+    mtexecutor.add_node(mocha)
 
     # Use context manager for clean shutdown
     try:
         # Spin with periodic checking for shutdown
-        while rclpy.ok() and not integrate_db.shutdownTriggered.is_set():
+        while rclpy.ok() and not mocha.shutdownTriggered.is_set():
             mtexecutor.spin_once(timeout_sec=0.1)
     except KeyboardInterrupt:
         print("Keyboard Interrupt")
-        integrate_db.shutdown("KeyboardInterrupt")
+        mocha.shutdown("KeyboardInterrupt")
     except Exception as e:
         print(f"Exception: {e}")
-        integrate_db.shutdown(f"Exception: {e}")
+        mocha.shutdown(f"Exception: {e}")
     finally:
         # Clean up node and ROS2 from main thread (safe)
-        integrate_db.destroy_node()
+        mocha.destroy_node()
         rclpy.shutdown()
 
 if __name__ == "__main__":

mocha_core/mocha_core/translator.py

@@ -31,7 +31,7 @@ def __init__(
 
         # Create service client
         self.add_update_db_cli = self.ros_node.create_client(AddUpdateDB,
-                                                             "/integrate_database/add_update_db",
+                                                             "/mocha/add_update_db",
                                                              qos_profile=ds.DatabaseServer.QOS_PROFILE)
         wait_counter = 0
         while not self.add_update_db_cli.wait_for_service(timeout_sec=1.0):

mocha_core/setup.py

@@ -19,12 +19,12 @@
     tests_require=["pytest"],
     entry_points={
         "console_scripts": [
-            "integrate_database = mocha_core.integrate_database:main",
+            "mocha = mocha_core.mocha:main",
             "database_server = mocha_core.database_server:main",
             "synchronize_channel = mocha_core.synchronize_channel:main",
             "zmq_comm_node = mocha_core.zmq_comm_node:main",
             "topic_publisher = mocha_core.topic_publisher:main",
             "translator = mocha_core.translator:main",
         ],
     },
-)
+)

mocha_core/test/test_translator.py

@@ -30,7 +30,7 @@
 class Database_server_test(Node):
     def __init__(self):
         # Important to match the topic that the translator expects
-        super().__init__("integrate_database")
+        super().__init__("mocha")
 
 
 class test_translator(unittest.TestCase):
@@ -155,7 +155,7 @@ def test_translator_processes_messages(self):
             # Use the translator node's service client to query the database
             select_client = translator_node.create_client(
                 SelectDB,
-                "/integrate_database/select_db",
+                "/mocha/select_db",
                 qos_profile=ds.DatabaseServer.QOS_PROFILE
             )
             while not select_client.wait_for_service(timeout_sec=1.0):
@@ -288,7 +288,7 @@ def topic_publisher(topic_id, topic_info, msgs_count):
 
             select_client = translator_node.create_client(
                 SelectDB,
-                "/integrate_database/select_db",
+                "/mocha/select_db",
                 qos_profile=ds.DatabaseServer.QOS_PROFILE
             )
             while not select_client.wait_for_service(timeout_sec=1.0):