Implement max number of attempts to connect to other backend processes when starting up the backend

Author: dieriver

CHANGELOG.md

@@ -10,6 +10,8 @@ For more details refer to the [documentation](https://softwarequtech.github.io/S
   nodes defined in the network configuration.
 - macOS Support: use "pollreactor" in macOS platforms to correctly allow starting backend processes.
 - Avoid using port 8021, which is used by a system service in macOS platforms.
+- Starting the SimulaQron backend now respects the "conn_max_retries" configuration when backend processes
+  try to connect to each other.
 
 
 2026-04-23 (v4.1.1)

simulaqron/start/start_qnodeos.py

@@ -30,7 +30,7 @@ def _init_register(virt_root, my_name: str, node: NetQASMFactory):
     _setup_netqasm_server(my_name, node)
 
 
-def _connect_to_virt_node(my_name: str, netqasm_factory: NetQASMFactory, virtual_network: SocketsConfig):
+def _connect_to_virt_node(my_name: str, netqasm_factory: NetQASMFactory, virtual_network: SocketsConfig, attempt: int = 0):
     """Tries to connect to local virtual node.
 
     If connection is refused, we try again after a set amount of time
@@ -49,36 +49,38 @@ def _connect_to_virt_node(my_name: str, netqasm_factory: NetQASMFactory, virtual
     defer_virtual_node.addCallback(_init_register, my_name, netqasm_factory)
     # If connection fails do:
     defer_virtual_node.addErrback(_handle_connection_error, my_name, netqasm_factory, virtual_network,
-                                  virtual_node.hostname, virtual_node.port)
+                                  virtual_node.hostname, virtual_node.port, attempt)
 
 
 def _handle_connection_error(reason, my_name: str, netqasm_factory: NetQASMFactory, virtual_network: SocketsConfig,
-                             virtual_node_hostname: str, virtual_node_port: int):
+                             virtual_node_hostname: str, virtual_node_port: int, attempt: int):
     """ Handles errors from trying to connect to local virtual node.
 
     If a ConnectionRefusedError is raised another try will be made after
     Settings.CONF_WAIT_TIME seconds. Any other error is raised again.
     """
     try:
         reason.raiseException()
-    except ConnectionRefusedError as err:
-        # TODO - Implement checking of max number of connections
-        logger.debug("START_QNODEOS %s: Could not connect to Virtual node (%s, %d), trying again...", my_name,
-                     virtual_node_hostname, virtual_node_port, exc_info=err)
-        reactor.callLater(
-            simulaqron_settings.conn_retry_time,
-            _connect_to_virt_node,
-            my_name,
-            netqasm_factory,
-            virtual_network,
-        )
-    except Exception as e:
-        logger.error(
-            "START_QNODEOS %s: Critical error when connection to local virtual node: %s",
-            my_name,
-            e,
-        )
-        reactor.stop()
+    except Exception as err:
+        if attempt > simulaqron_settings.conn_max_retries:
+            logger.exception(
+                "START_QNODEOS %s: Exhausted the maximum number of attempts to connect to local virtual node",
+                my_name,
+                exc_info=err,
+            )
+            reactor.stop()
+            return
+        else:
+            logger.debug("START_QNODEOS %s: Could not connect to Virtual node (%s, %d), trying again...", my_name,
+                         virtual_node_hostname, virtual_node_port, exc_info=err)
+            reactor.callLater(
+                simulaqron_settings.conn_retry_time,
+                _connect_to_virt_node,
+                my_name,
+                netqasm_factory,
+                virtual_network,
+                attempt + 1
+            )
 
 
 def _setup_netqasm_server(my_name: str, netqasm_factory: NetQASMFactory):
@@ -120,7 +122,7 @@ def _sigterm_handler(_signo, _stack_frame):
     reactor.stop()
 
 
-def start_qnodeos(node_name: str, network_config_file: Path, network_name: str = "default", log_level: str = "WARNING"):
+def start_qnodeos(node_name: str, network_config_file: Path, network_name: str):
     """
     Start the QNPU that accepts NetQASM subroutines, and sends them as instructions to the SimulaQron virtual node
     backend over twisted PB (Native Mode SimulaQron).
@@ -131,8 +133,6 @@ def start_qnodeos(node_name: str, network_config_file: Path, network_name: str =
     :type network_config_file: Path
     :param network_name: Name of the network (e.g., 'default').
     :type network_name: str
-    :param log_level: Logging level (e.g., 'DEBUG', 'INFO', 'WARNING').
-    :type log_level: str
     """
 
     # Let's ensure we read the config file

simulaqron/start/start_vnode.py

@@ -94,7 +94,7 @@ def start_vnode(name: str, network_config_file: Path, network_name: str, nodes_r
     logger.debug("START_VNODE: Starting VIRTUAL NODE %s", name)
 
     # Start the backend with the parameters configured in the simulaqron log file
-    be = Backend(name, network_name=network_name)
+    be = Backend(name, nodes_running, network_name=network_name)
     be.start(max_qubits=simulaqron_settings.max_qubits, max_registers=simulaqron_settings.max_registers)
 
     # Print a message we have terminated the node.

simulaqron/virtual_node/virtual.py

@@ -176,6 +176,7 @@ def __init__(self, ID: Host, config: SocketsConfig,
         :type maxRegisters: int
         """
         self._logger = logging.getLogger(f"{self.__class__.__name__}({ID.name})")
+        self._attempt = 0
 
         # Store our own host identifiers and configuration
         self.myID = ID
@@ -203,7 +204,7 @@ def __init__(self, ID: Host, config: SocketsConfig,
         self.virtQubits = []
         self.simQubits = []
 
-        # Set up connections to the neighouring nodes in the network
+        # Set up connections to the (Virtual Nodes processes) neighbouring nodes in the network
         self.connectNet()
 
         # Global lock: needs to be acquire whenever we want to manipulate more than one
@@ -293,7 +294,7 @@ def handle_connection(self, obj, node: Host):
         # Add this node to the local connections
         self.conn[node.name] = node
 
-    def handle_connection_error(self, reason, node):
+    def handle_connection_error(self, reason, node: Host):
         """
         Handles errors from trying to connect to other node.
         If a ConnectionRefusedError is raised another try will be made after `conn_retry_time`` seconds
@@ -303,13 +304,20 @@ def handle_connection_error(self, reason, node):
 
         try:
             reason.raiseException()
-        except ConnectionRefusedError as err:
-            self._logger.debug("Could not connect to %s (%s, %d), trying again...",
-                               node.name, node.hostname, node.port, exc_info=err)
-            reactor.callLater(simulaqron_settings.conn_retry_time, self.connect_to_node, node)
-        except Exception as e:
-            self._logger.exception(e)
-            reactor.stop()
+        except Exception as err:
+            if self._attempt > simulaqron_settings.conn_max_retries:
+                self._logger.exception(
+                    "Exhausted the maximum number of attempts to connect to neighbour virtual node '%s'",
+                    node.hostname,
+                    exc_info=err
+                )
+                reactor.stop()
+            else:
+                self._logger.debug("Could not connect to %s (%s, %d), trying again...",
+                                   node.name, node.hostname, node.port, exc_info=err)
+                self._attempt = self._attempt + 1
+                reactor.callLater(simulaqron_settings.conn_retry_time, self.connect_to_node, node)
+
 
     def _get_virtual_id(self):
         """