QuNetSim Issues

[Majidk2024]

Describe the bug

• The QunetSim classical channel is not delivering messages.
• The problem is with QunetSim, not your code.

To Reproduce
import select
from sctp import sctpsocket_tcp
from socket import AF_INET
from threading import Thread
from qunetsim.components import Host, Network
from qunetsim.objects.connections.classical_connection import ClassicalConnection
from qunetsim.backends import EQSNBackend
import time

Network Configuration

CU_IP = "10.108.202.32"
DU_IP = "10.108.202.33"
TUNNEL_IP = "10.109.202.32"
SCTP_PORT = 38472
BUFFER_SIZE = 128384
POLL_INTERVAL = 0.3

class QuantumTunnel:
def init(self):
self.setup_sockets()
self.data_counter = 0
self.debug = True
self.setup_quantum_network()

def debug_print(self, message):
    if self.debug:
        print(f"[DEBUG] {message}")

def setup_sockets(self):
    self.server_socket = sctpsocket_tcp(AF_INET)
    self.server_socket.bind((TUNNEL_IP, SCTP_PORT))
    self.server_socket.listen(1)

    self.du_conn, self.du_addr = self.server_socket.accept()
    self.du_conn.setblocking(False)
    print(f"[INFO] DU connected from {self.du_addr}")

    self.cu_socket = sctpsocket_tcp(AF_INET)
    self.cu_socket.connect((DU_IP, SCTP_PORT))
    self.cu_socket.setblocking(False)
    print("[INFO] Connected to CU")

def setup_quantum_network(self):
    # Set the backend explicitly to EQSN
    Network.get_instance().backend = EQSNBackend()

    # Initialize hosts
    self.qdu = Host('QDU')
    self.qcu = Host('QCU')
    
    # Create classical connection
    self.debug_print("Creating classical connection between QDU and QCU")
    connection = ClassicalConnection('QDU', 'QCU')
    self.qdu.add_connection(connection)
    self.qcu.add_connection(connection)

    # QDU protocol: receives from QCU and forwards to DU
    @self.qdu.run_protocol
    def qdu_protocol(host):
        print("[INFO] QDU protocol started")
        while True:
            self.debug_print("QDU polling for messages from QCU")
            message = host.get_next_classical('QCU')
            if message is not None:
                self.debug_print(f"QDU received from QCU: {str(message.content)[:20]}...")
                self.forward_to_du(message.content)
            time.sleep(0.1)

    # QCU protocol: receives from QDU and forwards to CU
    @self.qcu.run_protocol
    def qcu_protocol(host):
        print("[INFO] QCU protocol started")
        while True:
            self.debug_print("QCU polling for messages from QDU")
            message = host.get_next_classical('QDU')
            if message is not None:
                self.debug_print(f"QCU received from QDU: {str(message.content)[:20]}...")
                self.forward_to_cu(message.content)
            time.sleep(0.1)

    # Initialize network
    self.network = Network.get_instance()
    self.debug_print("Adding hosts to network...")
    self.network.add_host(self.qdu)
    self.network.add_host(self.qcu)
    self.network.start()
    print("[INFO] Quantum network initialized")

# External data handlers
def receive_from_du(self, data):
    self.data_counter += 1
    self.debug_print(f"QDU received external data from DU: {len(data)} bytes (message #{self.data_counter})")
    self.qdu.send_classical('QCU', data)
    self.debug_print(f"QDU sent to QCU (message #{self.data_counter})")

def receive_from_cu(self, data):
    self.data_counter += 1
    self.debug_print(f"QCU received external data from CU: {len(data)} bytes (message #{self.data_counter})")
    self.qcu.send_classical('QDU', data)
    self.debug_print(f"QCU sent to QDU (message #{self.data_counter})")

# Internal forwarding
def forward_to_du(self, data):
    try:
        self.du_conn.send(data)
        self.debug_print(f"Forwarded {len(data)} bytes to DU")
    except Exception as e:
        print(f"[ERROR] Failed to forward to DU: {e}")

def forward_to_cu(self, data):
    try:
        self.cu_socket.send(data)
        self.debug_print(f"Forwarded {len(data)} bytes to CU")
    except Exception as e:
        print(f"[ERROR] Failed to forward to CU: {e}")

# Socket handlers
def handle_du_data(self):
    print("[INFO] DU handler started")
    while True:
        try:
            data = self.du_conn.recv(BUFFER_SIZE)
            if data:
                self.receive_from_du(data)
        except Exception as e:
            if str(e) != "[Errno 11] Resource temporarily unavailable":
                print(f"[ERROR] DU receive error: {e}")
        time.sleep(0.1)

def handle_cu_data(self):
    print("[INFO] CU handler started")
    while True:
        try:
            data = self.cu_socket.recv(BUFFER_SIZE)
            if data:
                self.receive_from_cu(data)
        except Exception as e:
            if str(e) != "[Errno 11] Resource temporarily unavailable":
                print(f"[ERROR] CU receive error: {e}")
        time.sleep(0.1)

def run(self):
    du_thread = Thread(target=self.handle_du_data)
    cu_thread = Thread(target=self.handle_cu_data)
    du_thread.daemon = True
    cu_thread.daemon = True
    du_thread.start()
    cu_thread.start()

    print("[INFO] Tunnel is running...")
    try:
        while True:
            select.select([self.server_socket, self.cu_socket], [], [], POLL_INTERVAL)
    except KeyboardInterrupt:
        print("\n[INFO] Shutting down tunnel...")
    finally:
        self.cleanup()

def cleanup(self):
    try:
        self.du_conn.close()
        self.cu_socket.close()
        self.server_socket.close()
        print("[INFO] Connections closed")
    except Exception as e:
        print(f"[ERROR] Cleanup error: {e}")

if name == "main":
tunnel = QuantumTunnel()
tunnel.run()

Expected behavior
I want the hosts (QDU and QCU) to mutually communicate

Screenshots

System:

• OS: PRETTY_NAME="Ubuntu 22.04.5 LTS"
  NAME="Ubuntu"
  VERSION_ID="22.04"
  VERSION="22.04.5 LTS (Jammy Jellyfish)"
  VERSION_CODENAME=jammy
  ID=ubuntu
  ID_LIKE=debian
  HOME_URL="https://www.ubuntu.com/"
  SUPPORT_URL="https://help.ubuntu.com/"
  BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
  PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
  UBUNTU_CODENAME=jammy

• Python Version:
  Python 3.10.12

Additional context
I am not able to send data from QDU ---------->QCU and vice-versa communication, its stuck like sending from QDU to QCU
the timeout is because the data is not received at the other ping pong server it reset the connection.

[Majidk2024]

iam trying to build a tunnel to connect the CU and DU, and for it I am trying with various simulaters, please help me