UDP Part ready!

src/core/udp_server.py

@@ -11,6 +11,7 @@ from core import utils
 
 
 class UDPServer(asyncio.DatagramTransport):
+    transport = None
 
     def __init__(self, core, host=None, port=None):
         super().__init__()
@@ -20,62 +21,83 @@ class UDPServer(asyncio.DatagramTransport):
         self.host = host
         self.port = port
         self.run = False
-        self.transport = None
+        # self.transport = transport
 
     def connection_made(self, transport):
-        self.transport = transport
+        self.log.debug("set connection transport")
+        # self.transport = self.transport()
 
-    def datagram_received(self, data, addr):
+    async def handle_datagram(self, data, addr):
-        cid = data[0] - 1
+        try:
-        code = data[2:3].decode()
+            cid = data[0] - 1
+            code = data[2:3].decode()
 
-        client = self.Core.get_client(cid=cid)
+            client = self.Core.get_client(cid=cid)
-        if client:
+            if client:
-            if client._udp_sock != (self.transport, addr):
+                if client._udp_sock != (self.transport, addr):
-                client._udp_sock = (self.transport, addr)
+                    client._udp_sock = (self.transport, addr)
-                self.log.debug(f"Set UDP Sock for CID: {cid}")
+                    self.log.debug(f"Set UDP Sock for CID: {cid}")
-        else:
+                match code:
-            self.log.debug(f"Client not found.")
+                    case "p":
+                        self.log.debug(f"[{cid}] Send ping")
+                        # TODO: Call event onSentPing
+                        self.transport.sendto(b"p", addr)  # Send ping
+                    case "Z":
+                        # TODO: Call event onChangePosition
+                        if client:
+                            await client._send(data[2:], to_all=True, to_self=False, to_udp=True)
+                    case _:
+                        self.log.debug(f"[{cid}] Unknown code: {code}")
+            else:
+                self.log.debug(f"Client not found.")
 
-        match code:
+        except Exception as e:
-            case "p":
+            self.log.error(f"Error handle_datagram: {e}")
-                self.log.debug(f"[{cid}] Send ping")
+
-                # TODO: Call event onSentPing
+    def datagram_received(self, *args, **kwargs):
-                self.transport.sendto(b"p", addr)  # Send ping
+        self.loop.create_task(self.handle_datagram(*args, **kwargs))
-            case "Z":
-                if client:
-                    client._send(data)
-                # TODO: Call event onChangePosition
-                pass
-            case _:
-                self.log.debug(f"[{cid}] Unknown code: {code}")
 
     def connection_lost(self, exc):
         if exc is not None and exc != KeyboardInterrupt:
             self.log.debug(f'Connection raised: {exc}')
         self.log.debug(f'Disconnected.')
+
+    def error_received(self, exc):
+        self.log.debug(f'error_received: {exc}')
+        self.log.exception(exc)
+        self.connection_lost(exc)
         self.transport.close()
 
     async def _start(self):
         self.log.debug("Starting UDP server.")
-        self.run = True
         try:
-            self.transport, _ = await self.loop.create_datagram_endpoint(
+            while self.Core.run:
-                lambda: UDPServer(self.Core),
+                await asyncio.sleep(0.2)
-                local_addr=(self.host, self.port)
+
-            )
+                d = UDPServer
-            self.log.debug(f"UDP server started on {self.transport.get_extra_info('sockname')}")
+                self.transport, p = await self.loop.create_datagram_endpoint(
-            return
+                    lambda: d(self.Core),
+                    local_addr=(self.host, self.port)
+                )
+                d.transport = self.transport
+
+                if not self.run:
+                    self.log.debug(f"UDP server started on {self.transport.get_extra_info('sockname')}")
+
+                self.run = True
+                while not self.transport.is_closing():
+                    await asyncio.sleep(0.2)
+                self.log.info("UDP сервер сдох 1")
         except OSError as e:
-            self.run = False
-            self.Core.run = False
             self.log.error("Cannot bind port or other error")
             self.log.exception(e)
         except Exception as e:
-            self.run = False
-            self.Core.run = False
             self.log.error(f"Error: {e}")
             self.log.exception(e)
+        finally:
+            self.log.info("UDP сервер сдох 2")
+            self.run = False
+            self.Core.run = False
 
     def _stop(self):
         self.log.debug("Stopping UDP server")

src/core/udp_server.pyi

@@ -6,23 +6,25 @@
 # (c) kuitoi.su 2023
 import asyncio
 from asyncio import DatagramTransport
-from typing import Tuple
+from typing import Tuple, List
 
 from core import utils
 from core.core import Core
 
 
 class UDPServer(asyncio.DatagramTransport):
+    transport: DatagramTransport = None
 
-    def __init__(self, core: Core, host=None, port=None):
+    def __init__(self, core: Core, host=None, port=None, transport=None):
         self.log = utils.get_logger("UDPServer")
         self.loop = asyncio.get_event_loop()
         self.Core = core
         self.host = host
         self.port = port
         self.run = False
-        self.transport: DatagramTransport = None
+        # self.transport: DatagramTransport = None
     def connection_made(self, transport: DatagramTransport): ...
+    async def handle_datagram(self, data: bytes, addr: Tuple[str, int]):
     def datagram_received(self, data: bytes, addr: Tuple[str, int]): ...
     async def _start(self) -> None: ...
     async def _stop(self) -> None: ...