3 things were fixed:

- The teleport example now no longer uses run_application which makes no sense when running on multiple
  machines

- The NetQASM server was fixed to allow only one application connection per node per time.

- We cleanup once an app disconnects. The above change made this cleanup quite simple, as the NetQASM
addition to simulaqron was not designed to support multiple apps per node.

This is a bug fix which allows the simulaqron backend (virtual node, netqasm node) to keep running
while the user applications can be executed multiple times.

Author: StephanieWehner

examples/distributed/teleport/README.txt

@@ -0,0 +1,63 @@
+
+Distributed version of the teleport example, using simple NetQASM code both for Alice and Bob.
+
+How to run this example:
+
+1. First of all, make sure you are not already running existing simulaqron programs. You can run
+
+simulaqron stop
+sh terminate.sh
+
+which should get rid of all things running for the teleport example itself. If you want to be a bit
+more radical and confident you are not running other things to preserve you can run:
+
+simulaqron stop
+pkill -9 python
+
+This will kill ALL python processes run by you so beware.
+
+If you have a debugging enabled, you may also wish to wipe old log files by running
+
+rm /tmp/simulaqron*
+
+
+Now you should have a clear slate!
+
+2. Now you can run this example:
+
+First, we want to start the simulaqron virtual node backend and the NetQASM frontend your apps will their NetQASM subroutines to. 
+
+
+** Single Machine
+If you are running everything on the same machine, first we start the simulaqron backend by typing
+
+simulaqron start --node Alice,Bob
+
+This needs to be done only once. Now type
+
+sh run.sh
+
+There is no need to restart the simulaqron backend again if you want to re-run your example. 
+
+** Multiple machines
+
+If you are starting on two different machines run:
+
+simulaqron start --node Alice
+simulaqron start --node Bob
+
+on the machines you will use as Alice and Bob respectively. Again this needs to be run only once.
+
+Now you can run:
+on Bob:
+python teleport-bob.py
+
+on Alice:
+python teleport-alice.py
+
+The code assumes you start Bob before starting Alice. Using your knowledge of network programming
+from our ping pong example - do you have an idea to make this more robust?
+
+
+
+

examples/distributed/teleport/network-alice.json

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# Check if SimulaQron is already running
+if [ ! -f ~/.simulaqron_pids/simulaqron_network_default.pid ]; then
+    simulaqron start --nodes=Alice,Bob --network-config-file ./networkConfig.json
+fi
+
+python3 teleport-bob.py &
+python3 teleport-alice.py
+
+
+
+
+

examples/distributed/teleport/network-bob.json

@@ -0,0 +1,22 @@
+[
+    {
+        "name": "default",
+        "nodes":  [
+            {
+                "Alice": {
+                    "app_socket": ["localhost", 8821],
+                    "qnodeos_socket": ["localhost", 8822],
+                    "vnode_socket": ["localhost", 8823]
+                }
+            },
+            {
+                "Bob": {
+                    "app_socket": ["localhost", 8831],
+                    "qnodeos_socket": ["localhost", 8832],
+                    "vnode_socket": ["localhost", 8833]
+                }
+            }
+        ],
+        "topology": null
+    }
+]

examples/distributed/teleport/run.sh

@@ -1,51 +1,29 @@
-from pathlib import Path
-
 from netqasm.runtime.settings import set_simulator
-from netqasm.runtime.application import default_app_instance
-
-from simulaqron.run.run import run_applications
-
 set_simulator("simulaqron")
 
-from netqasm.sdk.external import NetQASMConnection  # noqa: E402
-from netqasm.sdk import Qubit, EPRSocket  # noqa: E402
+from simulaqron.settings import simulaqron_settings
+simulaqron_settings.network_config_file = "./networkConfig.json"
 
+from netqasm.sdk.external import NetQASMConnection
+from netqasm.sdk import Qubit, EPRSocket
 
 def run_alice():
-    epr_socket: EPRSocket = EPRSocket("Bob")
+    epr_socket = EPRSocket("Bob")
     with NetQASMConnection("Alice", epr_sockets=[epr_socket]) as alice:
         # Create a qubit
         q = Qubit(alice)
         q.H()
-
         # Create entanglement
         epr = epr_socket.create_keep()[0]
-
         # Teleport
         q.cnot(epr)
         q.H()
         m1 = q.measure()
         m2 = epr.measure()
-    return m1, m2
+    return int(m1), int(m2)
 
 
 if __name__ == "__main__":
-    apps = default_app_instance(
-        [
-            ("Alice", run_alice)
-        ]
-    )
-    network_cfg_path = Path(__file__).parent / "network-alice.json"
-    raw_results = run_applications(
-        apps, use_app_config=False, enable_logging=False, network_cfg=network_cfg_path.resolve()
-    )
-
-    results = {}
-
-    for name, raw_result in raw_results[0].items():
-        if isinstance(raw_result, tuple):
-            results[name] = tuple(int(result) for result in raw_result)
-        else:
-            results[name] = int(raw_result)
+    results = run_alice()
+    print(f"Alice measurements: m1={results[0]}, m2={results[1]}")
 
-    print(results)

examples/distributed/teleport/simulaqron_network.json

@@ -1,41 +1,22 @@
-from pathlib import Path
-
 from netqasm.runtime.settings import set_simulator
+set_simulator("simulaqron")
 
-from netqasm.runtime.application import default_app_instance
-
-from simulaqron.run.run import run_applications
+from simulaqron.settings import simulaqron_settings
+simulaqron_settings.network_config_file = "./networkConfig.json"
 
-set_simulator("simulaqron")
-from netqasm.sdk.external import NetQASMConnection  # noqa: E402
-from netqasm.sdk import EPRSocket  # noqa: E402
+from netqasm.sdk.external import NetQASMConnection
+from netqasm.sdk import EPRSocket
 
 
 def run_bob():
-    epr_socket: EPRSocket = EPRSocket("Alice")
+    epr_socket = EPRSocket("Alice")
     with NetQASMConnection("Bob", epr_sockets=[epr_socket]):
         entangled_qubit = epr_socket.recv_keep()[0]
         meas = entangled_qubit.measure()
-    return meas
+    return int(meas)
 
 
 if __name__ == "__main__":
-    apps = default_app_instance(
-        [
-            ("Bob", run_bob)
-        ]
-    )
-    network_cfg_path = Path(__file__).parent / "network-alice.json"
-    raw_results = run_applications(
-        apps, use_app_config=False, enable_logging=False, network_cfg=network_cfg_path.resolve()
-    )
-
-    results = {}
-
-    for name, raw_result in raw_results[0].items():
-        if isinstance(raw_result, tuple):
-            results[name] = tuple(int(result) for result in raw_result)
-        else:
-            results[name] = int(raw_result)
+    result = run_bob()
+    print(f"Bob measurement: {result}")
 
-    print(results)

examples/distributed/teleport/teleport-alice.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env sh
+TEST_PIDS=$(ps aux | grep python | grep -E "teleport" | awk {'print $2'})
+if [ "$TEST_PIDS" != "" ]
+then
+        kill -9 $TEST_PIDS
+fi
+
+simulaqron stop
+
+# Check if SimulaQron is running
+if [ -f ~/.simulaqron_pids/simulaqron_network_default.pid ]; then
+    cat $HOME/.simulaqron_pids/simulaqron_network_default.pid | xargs kill -9 
+fi
+

examples/distributed/teleport/teleport-bob.py

@@ -85,10 +85,51 @@ def __init__(self, factory: "NetQASMFactory"):
         self._logger.debug("Initialized Protocol")
 
     def connectionMade(self):
+        self._logger.info("Connection made")
         pass
 
     def connectionLost(self, reason=connectionDone):
-        pass
+        self._logger.info(f"Connection lost: {reason}")
+        self.factory._active_protocol = None
+        self._cleanup_all()
+
+    def _cleanup_all(self):
+        """Clean up all state - Note that we allow only ONE connection
+        to one NetQASM node server at a time, making the below safe.
+
+        If we were to ever decide to allow multiple, the below is too radical
+        and decidedly unsafe.
+        """
+        self._logger.info("Cleaning up all state")
+        
+        # Clear qubit list
+        self.factory.qubitList.clear()
+        
+        # Clear protocol class state
+        NetQASMProtocol._next_q_id.clear()
+        NetQASMProtocol._next_ent_id.clear()
+        
+        # Clear executioner class state
+        from simulaqron.netqasm_backend.executioner import VanillaSimulaQronExecutioner
+        VanillaSimulaQronExecutioner._next_create_id.clear()
+        
+        # Clear executioner instance state
+        executor = self.messageHandler._executor
+        if hasattr(executor, '_network_stack'):
+            executor._network_stack._sockets.clear()
+        if hasattr(executor, '_epr_create_requests'):
+            executor._epr_create_requests.clear()
+        if hasattr(executor, '_epr_recv_requests'):
+            executor._epr_recv_requests.clear()
+        
+        # Reset shared memory
+        try:
+            from netqasm.sdk.shared_memory import SharedMemoryManager
+            SharedMemoryManager.reset_memories()
+        except Exception as e:
+            self._logger.debug(f"Could not reset shared memory: {e}")
+        
+        self._logger.info("Cleanup complete")
 
     def dataReceived(self, data):
         """
@@ -201,6 +242,12 @@ def __init__(
         # topology
         self.topology = network_config[network_name].topology
 
+        # Track active connection - we will allow only one at a time
+        # as the code for the netqasm backend was not designed for multiple
+        # even though the virtual Node backend of SimulaQron would allow 
+        # that
+        self._active_protocol = None
+
     def stop(self):
         yield call_method(self.virtRoot, "stop_vnode")
         reactor.stop()
@@ -209,7 +256,9 @@ def buildProtocol(self, addr):
         """
         Return an instance of NetQASMProtocol when a connection is made.
         """
-        return NetQASMProtocol(self)
+        protocol = NetQASMProtocol(self)
+        self._active_protocol = protocol
+        return protocol
 
     def set_virtual_node(self, virtRoot):
         """