Adapt the "distributed" version of the teleport to use the new SDK to run both in a single machine, and distributed.

Author: dieriver

examples/distributed/teleport/README.txt

@@ -0,0 +1,113 @@
+# Quantum teleport example
+Quantum teleport example, using simple NetQASM code both for Alice and Bob.
+
+
+# How to run
+
+First of all, make sure you are not already running existing simulaqron programs.
+
+
+## Initial cleanup
+
+You can run
+
+```shell
+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:
+
+```shell
+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:
+
+```shell
+rm /tmp/simulaqron*
+```
+
+This should leave you a clear slate. We can now start the application.
+
+
+## On a single machine
+If you are running everything on the same machine, first we start the simulaqron backend by typing
+
+```shell
+simulaqron start --node Alice,Bob
+```
+
+This needs to be done only once. Now type
+
+```shell
+sh run.sh
+```
+
+WARNING: It seems restarting the simulaqron backend is needed! - There is no need to restart the simulaqron backend again if you want to re-run your example. 
+
+
+## On multiple machines
+
+If you are starting on two different machines run, you first need to update the network configuration
+file. To run this example on different machines, it is necessary that both machines can reach each
+other via a network (or the internet). Additionally, you need to know the IP addresses of both
+machines.
+
+Assuming that the server (alice) will run on a machine with IP `192.168.0.1` and the client (bob)
+will run on the machine with IP `192.168.0.2`, modify the `simulaqron_network.json` file *on both*
+the server and the client to look like this:
+
+```json
+[
+    {
+        "name": "default",
+        "nodes":  [
+            {
+                "Alice": {
+                    "app_socket": ["192.168.0.1", 8821],
+                    "qnodeos_socket": ["192.168.0.1", 8822],
+                    "vnode_socket": ["192.168.0.1", 8823]
+                }
+            },
+            {
+                "Bob": {
+                    "app_socket": ["192.168.0.2", 9831],
+                    "qnodeos_socket": ["192.168.0.2", 9832],
+                    "vnode_socket": ["192.168.0.2", 9833]
+                }
+            }
+        ],
+        "topology": null
+    }
+]
+```
+
+Note that the `localhost` entries from Alice were changed to `192.168.0.1`. Similarly, the
+`localhost` entries from Bob were changed to `192.168.0.2`.
+
+After these modifications, yu can start the simulaqron backends by invoking:
+
+```shell
+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:
+```shell
+python teleport-bob.py
+```
+
+* on Alice:
+```shell
+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/teleport-alice.py

@@ -7,9 +7,9 @@ if [ ! -f ~/.simulaqron_pids/simulaqron_network_default.pid ]; then
 fi
 
 python3 teleport-bob.py &
+SERVERPID=$!
+sleep 1
 python3 teleport-alice.py
 
-
-
-
-
+# Kill the server after it was used
+kill -9 $SERVERPID

examples/distributed/teleport/teleport-bob.py

@@ -0,0 +1,52 @@
+from asyncio import StreamReader, StreamWriter
+from pathlib import Path
+
+from simulaqron.general.host_config import SocketsConfig
+from simulaqron.sdk.protocol import SimulaQronClassicalClient
+from simulaqron.settings import network_config
+from simulaqron.settings.network_config import NodeConfigType
+
+# This is recipe to use NetQASM with simulaqron backend.
+from netqasm.runtime.settings import set_simulator
+set_simulator("simulaqron")
+
+# Importing NetQASM connection, Qubit and EPR socket must be *after*
+# setting the simulator for NetQASM
+from netqasm.sdk.external import NetQASMConnection  # noqa: E402
+from netqasm.sdk import Qubit, EPRSocket  # noqa: E402
+
+
+async def run_alice(reader: StreamReader, writer: StreamWriter):
+    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()
+    # Any value that comes from NetQASm *need* to be retrieved ("casted" to int)
+    # *after* the connection is closed (or after flushing the connection, untested)
+    m1_val = int(m1)
+    m2_val = int(m2)
+    message = f"{m1_val}:{m2_val}"
+    writer.write(message.encode("utf-8"))
+    return m1_val, m2_val
+
+
+if __name__ == "__main__":
+    # Load the file network configuration file
+    network_config_file = Path("simulaqron_network.json")
+    network_config.read_from_file(network_config_file)
+
+    # Get the socket configuration for the sockets used for the application layer
+    sockets_config = SocketsConfig(network_config, "default", NodeConfigType.APP)
+
+    # Create the client
+    client = SimulaQronClassicalClient(sockets_config)
+    results = client.run_client("Bob", run_alice)
+    print(f"Alice measurements: m1={results[0]}, m2={results[1]}")

examples/new-sdk/teleport/README.md

@@ -0,0 +1,45 @@
+from asyncio import StreamReader, StreamWriter
+from pathlib import Path
+
+from simulaqron.general.host_config import SocketsConfig
+from simulaqron.sdk.protocol import SimulaQronClassicalServer
+from simulaqron.settings import network_config
+from simulaqron.settings.network_config import NodeConfigType
+
+from netqasm.runtime.settings import set_simulator
+set_simulator("simulaqron")
+
+from netqasm.sdk.external import NetQASMConnection  # noqa: E402
+from netqasm.sdk import EPRSocket  # noqa: E402
+
+
+async def run_bob(reader: StreamReader, writer: StreamWriter):
+    # We wait for the classical message first
+    corrections_bytes = await reader.read(255)
+    corrections = corrections_bytes.decode("utf-8").split(":")
+    epr_socket = EPRSocket("Alice")
+    with NetQASMConnection("Bob", epr_sockets=[epr_socket]):
+        entangled_qubit = epr_socket.recv_keep()[0]
+
+        if int(corrections[0]) == 1:
+            entangled_qubit.X()
+        if int(corrections[1]) == 1:
+            entangled_qubit.Z()
+        meas = entangled_qubit.measure()
+    # Any value that comes from NetQASm *need* to be retrieved ("casted" to int)
+    # *after* the connection is closed (or after flushing the connection, untested)
+    meas_val = int(meas)
+    print(f"Bob measurement: {meas_val}")
+
+if __name__ == "__main__":
+    # Load the file network configuration file
+    network_config_file = Path("simulaqron_network.json")
+    network_config.read_from_file(network_config_file)
+
+    # Get the socket configuration for the sockets used for the application layer
+    sockets_config = SocketsConfig(network_config, "default", NodeConfigType.APP)
+
+    # Create the client
+    server = SimulaQronClassicalServer(sockets_config, "Bob")
+    server.register_client_handler(run_bob)
+    server.start_serving()

examples/distributed/teleport/run.sh examples/new-sdk/teleport/run.shexamples/distributed/teleport/run.sh renamed to examples/new-sdk/teleport/run.sh

@@ -1,9 +1,11 @@
 import asyncio
 from asyncio import StreamWriter, StreamReader
-from typing import Awaitable, Optional, Callable
+from typing import Awaitable, Optional, Callable, Coroutine, Any, TypeVar
 
 from simulaqron.general.host_config import SocketsConfig
 
+_T = TypeVar("_T")
+
 
 class SimulaQronClassicalClient:
     def __init__(self, sockets_config: SocketsConfig):
@@ -16,16 +18,17 @@ def __init__(self, sockets_config: SocketsConfig):
         """
         self._sockets_config = sockets_config
 
-    async def _run_client(self, hostname: str, port: int, callback: Callable[[StreamReader, StreamWriter], Awaitable[None]]):
+    async def _run_client(self, hostname: str, port: int, callback: Coroutine[Any, Any, _T]) -> _T:
         """
         Python coroutine that opens the connection and runs the function provided by the user.
         """
         reader, writer = await asyncio.open_connection(hostname, port)
-        await callback(reader, writer)
+        result = await callback(reader, writer)
         writer.close()
+        return result
 
 
-    def run_client(self, node_name: str, callback: Callable[[StreamReader, StreamWriter], Awaitable[None]]) -> None:
+    def run_client(self, server_name: str, callback: Coroutine[Any, Any, _T]) -> _T:
         """
         Runs a function implementing a client that connects to the node with the given name.
         Once the connection has been established, the given callback will be executed to start
@@ -44,18 +47,18 @@ async def connected_handler(reader: StreamReader, writer: StreamWriter):
         Once the execution of the given function, the client will close the connection to
         the server.
 
-        :param node_name: The name of the node to connect to. The name *must* exist in the
+        :param server_name: The name of the server to connect to. The name *must* exist in the
                           configuration file given when constructing this client.
-        :type node_name: str
+        :type server_name: str
         :param callback: The function to be called when the connection is established. This function
                          implements the logic for interacting with the server. The passed function
                          *must* be a python "async" function.
         :type callback: Callable[[StreamReader, StreamWriter], Awaitable[None]]
         """
-        if node_name not in self._sockets_config.hostDict:
-            raise RuntimeError(f"The node with name '{node_name}' is not on the network configuration.")
-        socket_config = self._sockets_config.hostDict[node_name]
-        asyncio.run(self._run_client(socket_config.hostname, socket_config.port, callback))
+        if server_name not in self._sockets_config.hostDict:
+            raise RuntimeError(f"The node with name '{server_name}' is not on the network configuration.")
+        socket_config = self._sockets_config.hostDict[server_name]
+        return asyncio.run(self._run_client(socket_config.hostname, socket_config.port, callback))
 
 
 class SimulaQronClassicalServer: