Backend processes are started only for the requested nodes to run. The processes are started separately: VNode first, wait shorly, then QNodeOS

Author: dieriver

simulaqron/network.py

@@ -72,7 +72,8 @@ def __init__(self, nodes: List[str], network_config_file: Path, network_name: st
         self._running = False
         self.name = network_name
 
-        self.processes: List[Process] = []
+        self._virtual_node_processes: List[Process] = []
+        self._qnodeos_processes: List[Process] = []
         self._logger = logging.getLogger(f"{self.__class__.__name__}({self.name})")
 
         # Determine the nodes to start, using the in-memory network config
@@ -114,6 +115,10 @@ def running(self) -> bool:
     def __del__(self):
         self.stop()
 
+    @property
+    def processes(self) -> List[Process]:
+        return self._qnodeos_processes + self._virtual_node_processes
+
     def _setup_processes(self):
         """
         Setup the processes forming the network, however they are not started yet.
@@ -125,15 +130,16 @@ def _setup_processes(self):
         for node in self._nodes_to_start:
             process_virtual = Process(
                 target=start_vnode, 
-                args=(node.name, self._network_config_file, self.name, simulaqron_settings.log_level),
+                args=(node.name, self._network_config_file, self.name, [node.name for node in self._nodes_to_start]),
                 name=f"VirtNode {node.name}"
             )
             process_qnodeos = Process(
                 target=start_qnodeos, 
-                args=(node.name, self._network_config_file, self.name, simulaqron_settings.log_level),
+                args=(node.name, self._network_config_file, self.name),
                 name=f"QnodeOSNode {node.name}"
             )
-            self.processes += [process_virtual, process_qnodeos]
+            self._virtual_node_processes.append(process_virtual)
+            self._qnodeos_processes.append(process_qnodeos)
 
     def start(self, wait_until_running=False):
         """
@@ -143,9 +149,17 @@ def start(self, wait_until_running=False):
         :param wait_until_running: bool
         """
         self._logger.info("Starting network with name %s", self.name)
-        for p in self.processes:
+        for p in self._virtual_node_processes:
+            if not p.is_alive():
+                self._logger.debug("Starting Virtual Node process %s", p.name)
+                p.daemon = True
+                p.start()
+
+        time.sleep(1)
+
+        for p in self._qnodeos_processes:
             if not p.is_alive():
-                self._logger.debug("Starting process %s", p.name)
+                self._logger.debug("Starting QNodeOS process %s", p.name)
                 p.daemon = True
                 p.start()
 

simulaqron/start/start_vnode.py

@@ -32,7 +32,7 @@
 import sys
 from functools import partial
 from pathlib import Path
-
+from typing import List
 
 from simulaqron.reactor import reactor
 from simulaqron.virtual_node.virtual import Backend
@@ -52,7 +52,7 @@ def _sigterm_handler(name, _signo, _stack_frame):
     reactor.stop()
 
 
-def start_vnode(name: str, network_config_file: Path, network_name: str = "default", log_level: str = "WARNING"):
+def start_vnode(name: str, network_config_file: Path, network_name: str, nodes_running: List[str]):
     """
     Start the execution of a virtual simulaqron node. This node will simulate all quantum aspects
     of the node, and is then reachable via Twisted PB (Simulaqron Native Mode) or - when also starting QNPU - 
@@ -64,8 +64,8 @@ def start_vnode(name: str, network_config_file: Path, network_name: str = "defau
     :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
+    :param nodes_running: List of nodes running (e.g., ['Alice', 'Bob']).
+    :type nodes_running: List[str]
     """
 
     # Let's ensure we have read the config file. This relies on the right one being passed from network.py

simulaqron/virtual_node/virtual.py

@@ -33,7 +33,7 @@
 
 import logging
 from twisted.internet.defer import inlineCallbacks, DeferredLock, Deferred, DeferredList
-from twisted.internet.error import ConnectionRefusedError, CannotListenError
+from twisted.internet.error import CannotListenError
 from twisted.internet.task import deferLater
 from twisted.spread import pb
 from twisted.spread.pb import RemoteError, RemoteReference
@@ -102,22 +102,29 @@ def call_method(obj, method_name, *args, **kwargs):
 # forming the quantum network
 #
 class Backend:
-    def __init__(self, name: str, network_name: str = "default"):
+    def __init__(self, name: str, nodes_running: List[str], network_name: str):
         """
         Create the Virtual Node backend. This will read the networks configuration and
         populate the name,hostname,port information with the information found in the
         configuration file for the given name.
 
         :param name: Node name to start.
         :type name: str
-        :network_name: Name of the network to start.
+        :param nodes_running: List of nodes currently running.
+        :type nodes_running: List[str]
+        :param network_name: Name of the network to start.
         :type network_name: str
         """
         self._logger = logging.getLogger(f"{self.__class__.__name__}({name})")
 
         # Read the configuration file
         self.config = SocketsConfig(network_config, network_name=network_name, config_type="vnode")
+        # We only want to start connections to the nodes that are running, not to all
+        # of nodes that are defined in the network config
+        # To this end, we filter the loaded network config, so it contains only the running nodes
+        self.config.filter(nodes_running)
         self.myID: Host = self.config.hostDict[name]
+        self._logger.debug("myID: (name: %s) %s", name, str(self.myID))
 
     def start(
             self,
@@ -141,7 +148,7 @@ def start(
             self._logger.debug("Running reactor")
             reactor.run()
         except CannotListenError as exc:
-            self._logger.debug("NetQASM server address (%d) is already in use.", self.myID.port, exc_info=exc)
+            self._logger.debug("NetQASM server port (%d) is already in use.", self.myID.port, exc_info=exc)
             return
         except Exception as e:
             self._logger.debug("Critical error when starting local virtual node server", exc_info=e)