Disable __handle_packet...;

Fix "Invalid packet - header negative";
Fix _get_cid_vid;
Add dta to _handle_vehicle_codes;
Fix disconnected message.

src/core/Client.py

@@ -166,6 +166,10 @@ class Client:
                     await asyncio.sleep(0.1)
                     self.is_disconnected()
                     if self.__alive:
+                        if header == b"":
+                            self.__packets_queue.append(None)
+                            self.__alive = False
+                            continue
                         self.log.debug(f"Header: {header}")
                         await self.kick("Invalid packet - header negative")
                     self.__packets_queue.append(None)
@@ -178,13 +182,22 @@ class Client:
                     self.__packets_queue.append(None)
                     continue
 
-                data = await self.__reader.read(100 * MB)
+                data = await self.__reader.read(int_header)
+
+                self.log.debug(f"int_header: {int_header}; data: `{data}`;")
+                abg = b"ABG:"
+                if len(data) > len(abg) and data.startswith(abg):
+                    data = zlib.decompress(data[len(abg):])
+                    self.log.debug(f"ABG Packet: {len(data)}")
+
                 if one:
-                    self.log.debug(f"int_header: `{int_header}`; data: `{data}`;")
+                    # self.log.debug(f"int_header: `{int_header}`; data: `{data}`;")
                     return data
-                else:
+                # FIXME
-                    t = asyncio.create_task(self.__handle_packet(data, int_header))
+                # else:
-                    self.__tasks.append(t)
+                #     t = asyncio.create_task(self.__handle_packet(data, int_header))
+                #     self.__tasks.append(t)
+                self.__packets_queue.append(data)
 
             except ConnectionError:
                 self.__alive = False
@@ -276,7 +289,8 @@ class Client:
         return
 
     def _get_cid_vid(self, data: str):
-        s = data[:data.find(":", 1)]
+        sep = data.find(":", 1) + 1
+        s = data[sep:sep + 3]
         id_sep = s.find('-')
         if id_sep == -1:
             self.log.debug(f"Invalid packet: Could not parse pid/vid from packet, as there is no '-' separator: '{data}'")
@@ -295,11 +309,11 @@ class Client:
         self.log.debug(f"Invalid packet: Could not parse pid/vid from packet: '{data}'")
         return -1, -1
 
-    async def _handle_vehicle_codes(self, data):
+    async def _handle_vehicle_codes(self, dta):
-        if len(data) < 6:
+        if len(dta) < 6:
             return
-        sub_code = data[1]
+        sub_code = dta[1]
-        data = data[3:]
+        data = dta[3:]
         match sub_code:
             case "s":  # Spawn car
                 self.log.debug("Trying to spawn car")
@@ -337,10 +351,10 @@ class Client:
                         await self._send(des)
             case "d":  # Delete car
                 self.log.debug("Trying to delete car")
-                cid, car_id = self._get_cid_vid(data)
+                cid, car_id = self._get_cid_vid(dta)
                 if car_id != -1 and cid == self.cid:
                     # TODO: Call event onCarDelete
-                    await self._send(data, to_all=True, to_self=True)
+                    await self._send(dta, to_all=True, to_self=True)
                     try:
                         car = self.cars[car_id]
                         if car['unicycle']:
@@ -355,7 +369,7 @@ class Client:
                 self.log.debug("Trying to edit car")
                 allow = True
                 # TODO: Call event onCarEdited
-                cid, car_id = self._get_cid_vid(data)
+                cid, car_id = self._get_cid_vid(dta)
                 if car_id != -1 and cid == self.cid:
                     try:
                         car = self.cars[car_id]
@@ -363,7 +377,7 @@ class Client:
                             self._cars.pop(car_id)
                             await self._send(f"Od:{self.cid}-{car_id}", to_all=True, to_self=True)
                         elif allow:
-                            await self._send(data, to_all=True, to_self=False)
+                            await self._send(dta, to_all=True, to_self=False)
                             if car['json_ok']:
                                 old_car_json = car['json']
                                 try:
@@ -378,16 +392,16 @@ class Client:
                         self.log.debug(f"Unknown car: car_id={car_id}")
             case "r":  # Reset car
                 self.log.debug("Trying to reset car")
-                cid, car_id = self._get_cid_vid(data)
+                cid, car_id = self._get_cid_vid(dta)
                 if car_id != -1 and cid == self.cid:
                     # TODO: Call event onCarReset
-                    await self._send(data, to_all=True, to_self=False)
+                    await self._send(dta, to_all=True, to_self=False)
                     self.log.debug(f"Car reset: car_id={car_id}")
             case "t":
-                self.log.debug(f"Received 'Ot' packet: {data}")
+                self.log.debug(f"Received 'Ot' packet: {dta}")
-                await self._send(data, to_all=True, to_self=False)
+                await self._send(dta, to_all=True, to_self=False)
             case "m":
-                await self._send(data, to_all=True, to_self=True)
+                await self._send(dta, to_all=True, to_self=True)
 
     async def _handle_codes(self, data):
         if not data:
@@ -488,9 +502,14 @@ class Client:
         self.__alive = False
         if (self.cid > 0 or self.nick is not None) and \
                 self.__Core.clients_by_nick.get(self.nick):
-            # if self.ready:
+            for i, car in enumerate(self.cars):
-            #     await self.tcp_send(b"", to_all=True)  # I'm disconnected.
+                if not car:
-            self.log.debug(f"Removing client {self.nick}:{self.cid}")
+                    continue
+                self.log.debug(f"Removing car: car_id={i}")
+                await self._send(f"Od:{self.cid}-{i}", to_all=True, to_self=False)
+            if self.ready:
+                await self._send(f"J{self.nick} disconnected!", to_all=True, to_self=False)  # I'm disconnected.
+            self.log.debug(f"Removing client")
             # TODO: i18n
             self.log.info("Disconnected")
             self.__Core.clients[self.cid] = None

src/core/tcp_server.py

@@ -143,7 +143,7 @@ class TCPServer:
         self.run = True
         try:
             server = await asyncio.start_server(self.handle_client, self.host, self.port,
-                                                backlog=int(config.Game["players"] * 1.3))
+                                                backlog=int(config.Game["players"] * 2.3))
             self.log.debug(f"TCP server started on {server.sockets[0].getsockname()!r}")
             while True:
                 async with server:

src/core/udp_server.py

@@ -10,42 +10,36 @@ import traceback
 from core import utils
 
 
-class UDPServer:
+class UDPServer(asyncio.DatagramTransport):
 
-    def __init__(self, core, host, port):
+    def __init__(self, core, host=None, port=None):
+        super().__init__()
         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 = None
 
-    async def handle_client(self, reader, writer):
+    def connection_made(self, transport):
-        while True:
+        self.transport = transport
-            try:
+
-                data = await reader.read(1)
+    def datagram_received(self, data, addr):
-                if not data:
+        message = data.decode()
-                    break
+        print('Received %r from %s' % (message, addr))
-                code = data.decode()
+        print('Send %r to %s' % (message, addr))
-                self.log.debug(f"Received {code!r} from {writer.get_extra_info('sockname')!r}")
+        self.transport.sendto(data, addr)
-                # await self.handle_code(code, reader, writer)
-                # task = asyncio.create_task(self.handle_code(code, reader, writer))
-                # await asyncio.wait([task], return_when=asyncio.FIRST_EXCEPTION)
-                if not writer.is_closing():
-                    writer.close()
-                self.log.debug("Disconnected.")
-                break
-            except Exception as e:
-                self.log.error("Error while connecting..")
-                self.log.error(f"Error: {e}")
-                traceback.print_exc()
-                break
 
     async def start(self):
         self.log.debug("Starting UDP server.")
         self.run = True
         try:
-            pass
+            self.transport, _ = await self.loop.create_datagram_endpoint(
+                lambda: self,
+                local_addr=(self.host, self.port),
+                reuse_port=True
+            )
         except OSError as e:
             self.log.error("Cannot bind port or other error")
             raise e
@@ -58,3 +52,4 @@ class UDPServer:
 
     def stop(self):
         self.log.debug("Stopping UDP server")
+        self.transport.close()

src/core/udp_server.pyi

@@ -5,20 +5,22 @@
 # Licence: FPA
 # (c) kuitoi.su 2023
 import asyncio
+from typing import Tuple
 
 from core import utils
 
 
 class UDPServer:
 
-    def __init__(self, core, host, port):
+    def __init__(self, core, host=None, port=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
-    async def handle_client(self, srv_sock) -> None: ...
+        self.transport = None
+    def connection_made(self, transport: asyncio.DatagramTransport): ...
+    def datagram_received(self, data: bytes, addr: Tuple[str, int]): ...
     async def start(self) -> None: ...
-
     async def stop(self) -> None: ...