P2P RTC connection using a STUN server.

[Godwhitelight]

Im trying to make an echo p2p connection using a STUN server.
I understood that it should go like that:
Both clients need to create an RTCPeerConnection.
Each client creates a data channel on their RTCPeerConnection.
Each client creates an offer, sets it as their local description, and sends it to the server.
The server forwards the offer from one client to the other.
Upon receiving an offer, a client sets it as their remote description, creates an answer, sets it as their local description, and sends it back to the server.
The server forwards the answer from one client to the other.
Upon receiving an answer, a client sets it as their remote description.

and im getting an error.

Exception in thread Thread-1:
Traceback (most recent call last):
  File "C:\Users\*****\AppData\Local\Programs\Python\Python39\lib\threading.py", line 980, in _bootstrap_inner
    self.run()
  File "C:\Users\*****\AppData\Local\Programs\Python\Python39\lib\threading.py", line 917, in run
    self._target(*self._args, **self._kwargs)
  File "C:\*****\rtc_tests\c.py", line 27, in run
    loop.run_until_complete(self.client())
  File "C:\Users\*****\AppData\Local\Programs\Python\Python39\lib\asyncio\base_events.py", line 647, in run_until_complete
    return future.result()
  File "C:\*****\rtc_tests\c.py", line 62, in client
    await pc.setRemoteDescription(RTCSessionDescription(sdp=offer_sdp, type="offer"))
  File "C:\*****\venv\lib\site-packages\aiortc\rtcpeerconnection.py", line 827, in setRemoteDescription
    self.__validate_description(description, is_local=False)
  File "C:\*****\venv\lib\site-packages\aiortc\rtcpeerconnection.py", line 1244, in __validate_description
    raise InvalidStateError(
aiortc.exceptions.InvalidStateError: Cannot handle offer in signaling state "have-local-offer"

here is my server that sends the data to the 2 clients:

import asyncio
import websockets
from aiortc import RTCPeerConnection, RTCSessionDescription, RTCIceServer, RTCConfiguration

clients = set()

async def handle_client(websocket, path):
    print(f"Connection established from {websocket.remote_address}")

    clients.add(websocket)
    other_client = None
    while other_client is None:
        await asyncio.sleep(0.1)
        for client in clients:
            if client != websocket and client.open:
                other_client = client
                break

    print(f"Found other client: {other_client.remote_address}")

    data = await websocket.recv()
    await other_client.send(data)

    print('send first set of data')
    data = await websocket.recv()
    await other_client.send(data)

    print("Connection established")
    # Keep the connection open until it is closed
    await asyncio.Event().wait()

    print(f"Connection closed by {websocket.remote_address}")

async def server():
    server = await websockets.serve(handle_client, "localhost", 12345)
    print("WebSocket server listening on ws://localhost:12345")

    try:
        await asyncio.Future()  # Run the server indefinitely
    except KeyboardInterrupt:
        print("Server terminated by user.")
        server.close()
        await server.wait_closed()

if __name__ == "__main__":
    asyncio.run(server())

here is the client:

import asyncio
import websockets
import threading
import queue
from aiortc import RTCPeerConnection, RTCSessionDescription, RTCConfiguration, RTCIceServer


class SyncClient:
    def __init__(self):
        self.loop = asyncio.new_event_loop()
        self.queue = queue.Queue()
        self.thread = threading.Thread(target=self.run, args=(self.loop,))
        self.channel = None

    def start(self):
        self.thread.start()

    def stop(self):
        self.loop.call_soon_threadsafe(self.loop.stop)
        self.thread.join()

    def send_message(self, message):
        self.queue.put(message)

    def run(self, loop):
        asyncio.set_event_loop(loop)
        loop.run_until_complete(self.client())
        loop.close()

    def on_datachannel(self, channel):
        self.channel = channel
        channel.on("message", self.on_message)
        print("Data channel created successfully")

    def on_message(self, message):
        print(f"Received message from server: {message}")

    async def client(self):
        uri = "ws://localhost:12345"
        async with websockets.connect(uri) as websocket:
            print(f"Connected to {uri}")

            # Create a new RTCPeerConnection
            configuration = RTCConfiguration(
                iceServers=[
                    RTCIceServer(urls=["stun:stun.l.google.com:19302"]),
                ]
            )
            pc = RTCPeerConnection(configuration=configuration)

            # Create a data channel
            pc.createDataChannel("data", ordered=True)
            pc.on("datachannel", self.on_datachannel)
            # Create an offer
            offer = await pc.createOffer()
            await pc.setLocalDescription(offer)

            # Send the offer to the server
            await websocket.send(offer.sdp)
            # Receive the offer from the server
            offer_sdp = await websocket.recv()
            await pc.setRemoteDescription(RTCSessionDescription(sdp=offer_sdp, type="offer"))

            print('send first set of data')
            # Create and send the answer to the server

            answer = await pc.createAnswer()
            await pc.setLocalDescription(answer)
            print(f"Sending answer to server: {pc.localDescription.sdp}")
            await websocket.send(pc.localDescription.sdp)

            # Receive the answer from the server
            answer_sdp = await websocket.recv()
            await pc.setRemoteDescription(RTCSessionDescription(sdp=answer_sdp, type="answer"))

            # Send a message to the server
            while self.channel is None:
                await asyncio.sleep(0.1)
            print("starting to send queued messages")
            while True:
                try:
                    message = self.queue.get(block=False)
                    self.channel.send(message)
                except queue.Empty:
                    await asyncio.sleep(0.1)

if __name__ == "__main__":
    client = SyncClient()
    client.start()

    while True:
        msg = input("Enter message: ")
        if msg == "quit":
            break
        client.send_message(msg)

    client.stop()

[HysUnknown]

Before
pc.createOffer()
or
pc.createAnswer()
you need to stream the audio and video into track
pc.addTrack(track)
otherwise the signaling status will not change to 'have-local-offer'.