[~] Minor

src/core/Client.py

@@ -355,11 +355,10 @@ class Client:
                     speed = speed / 2
                 half_size = math.floor(size / 2)
                 t = time.monotonic()
-                uploads = [
+                async with asyncio.TaskGroup() as tg:
-                    self._split_load(0, half_size, False, file, speed),
+                    sl0 = tg.create_task(self._split_load(0, half_size, False, file, speed))
-                    self._split_load(half_size, size, True, file, speed)
+                    sl1 = tg.create_task(self._split_load(half_size, size, True, file, speed))
-                ]
+                sl0, sl1 = sl0.result(), sl1.result()
-                sl0, sl1 = await asyncio.gather(*uploads)
                 tr = (time.monotonic() - t) or 0.0001
                 if self._core.lock_upload:
                     self._core.lock_upload = False
@@ -691,7 +690,7 @@ class Client:
             self.__alive = False
             return
         if len(data) == 0:
-            self.__alive = False
+            await self.kick("Bad data from client")
             return
 
         _bytes = False
@@ -768,6 +767,7 @@ class Client:
         self.udp_pps = self._udp_count_recv
         self._tpc_count_recv = 0
         self._udp_count_recv = 0
+        self.log.debug("PPS")
         if self.tcp_pps > self._core.target_tps or self.udp_pps > self._core.target_tps:
             self.log.warning(f"PPS > TPS; PPS: TPC: {self.tcp_pps}, UDP: {self.udp_pps}")
 
@@ -810,9 +810,9 @@ class Client:
         await self._send(f"P{self.cid}")  # Send clientID
         await self._sync_resources()
         ev.call_lua_event("onPlayerJoining", self.cid)
-        ev.register("serverTick", self.__tick_player_tcp)
+        self.__tpt_id = ev.register("serverTick", self.__tick_player_tcp)
-        ev.register("serverTick", self.__tick_player_udp)
+        self.__tpu_id = ev.register("serverTick", self.__tick_player_udp)
-        ev.register("serverTick_1s", self._tick_pps)
+        self.__tpp_id = ev.register("serverTick_1s", self._tick_pps)
         await self._recv()
 
     async def _remove_me(self):
@@ -830,18 +830,22 @@ class Client:
             ev.call_lua_event("onPlayerDisconnect", self.cid)
             ev.call_event("onPlayerDisconnect", player=self)
             await ev.call_async_event("onPlayerDisconnect", player=self)
-            ev.unregister(self.__tick_player_tcp)
+            ev.unregister_by_id(self.__tpt_id)  # self.__tick_player_tcp
-            ev.unregister(self.__tick_player_udp)
+            ev.unregister_by_id(self.__tpu_id)  # self.__tick_player_udp
-            ev.unregister(self._tick_pps)
+            ev.unregister_by_id(self.__tpp_id)  # self._tick_pps
             gt = round((time.monotonic() - self._connect_time) / 60, 2)
             self.log.info(i18n.client_player_disconnected.format(gt))
             self._core.clients[self.cid] = None
             del self._core.clients_by_id[self.cid]
             del self._core.clients_by_nick[self.nick]
+            self.log.debug(f"TPC: "
+                           f"Recv: {self._tpc_count_total_recv}; {self._tpc_size_total_recv / KB:.4f}kb; "
+                           f"Sent: {self._tpc_count_total_sent}; {self._tpc_size_total_sent / KB:.4f}kb;")
+            self.log.debug(f"UDP: "
+                           f"Recv: {self._udp_count_total_recv}; {self._udp_size_total_recv / KB:.4f}kb; "
+                           f"Sent: {self._udp_count_total_sent}; {self._udp_size_total_sent / KB:.4f}kb;")
         else:
             self.log.debug(f"Removing client; Closing connection...")
-        self.log.debug(f"TPC: Recv: {self._tpc_count_total_recv}; {self._tpc_size_total_recv / KB:.4f}kb; Sent: {self._tpc_count_total_sent}; {self._tpc_size_total_sent / KB:.4f}kb;")
-        self.log.debug(f"UDP: Recv: {self._udp_count_total_recv}; {self._udp_size_total_recv / KB:.4f}kb; Sent: {self._udp_count_total_sent}; {self._udp_size_total_sent / KB:.4f}kb;")
         await asyncio.sleep(0.001)
         try:
             self.__writer.close()

src/core/Client.pyi

@@ -55,6 +55,9 @@ class Client:
         self._unicycle: Dict[str, Union[int, str]]  = {"id": -1, "packet": ""}
         self._last_position = {}
         self._lock = Lock()
+        self.__tpt_id = 0
+        self.__tpu_id = 0
+        self.__tpp_id = 0
 
     async def __gracefully_kick(self): ...
     @property
@@ -92,7 +95,7 @@ class Client:
     async def _send(self, data: bytes | str, to_all: bool = False, to_self: bool = True, to_udp: bool = False, writer: StreamWriter = None) -> None: ...
     async def _sync_resources(self) -> None: ...
     async def _recv(self, one=False) -> bytes | None: ...
-    async def _split_load(self, start: int, end: int, d_sock: bool, filename: str, sl: float) -> None: ...
+    async def _split_load(self, start: int, end: int, d_sock: bool, filename: str, sl: float) -> int: ...
     async def _get_cid_vid(self, s: str) -> Tuple[int, int]: ...
     async def _spawn_car(self, data: str) -> None: ...
     async def delete_car(self, car_id: int) -> None: ...

src/core/__init__.py

@@ -10,7 +10,7 @@ __title__ = 'KuiToi-Server'
 __description__ = 'BeamingDrive Multiplayer server compatible with BeamMP clients.'
 __url__ = 'https://github.com/kuitoi/kuitoi-Server'
 __version__ = '0.4.8'
-__build__ = 2679  # Я это считаю лог файлами
+__build__ = 2747  # Я это считаю лог файлами
 __author__ = 'SantaSpeen'
 __author_email__ = 'admin@anidev.ru'
 __license__ = "FPA"
@@ -19,6 +19,7 @@ __copyright__ = 'Copyright 2024 © SantaSpeen (Maxim Khomutov)'
 import asyncio
 import builtins
 import sys
+import time
 import webbrowser
 
 import prompt_toolkit.shortcuts as shortcuts
@@ -30,15 +31,17 @@ from modules import ConfigProvider, EventsSystem
 from modules import Console
 from modules import MultiLanguage
 
+builtins.Ts = time.monotonic()
 args, _ = parser.parse_known_args()
 if args.version:
     print(f"{__title__}:\n\tVersion: {__version__}\n\tBuild: {__build__}")
     exit(0)
 
 loop = asyncio.new_event_loop()
-asyncio.set_event_loop(loop)
 if sys.platform == 'win32':
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+# loop.set_task_factory(asyncio.eager_task_factory)
+asyncio.set_event_loop(loop)
 log = get_logger("core.init")
 
 # Config file init

src/core/tcp_server.py

@@ -126,9 +126,10 @@ class TCPServer:
                 result, client = await self.auth_client(reader, writer)
                 if result:
                     await client._looper()
-                return result, client
+                return "U", client
             case "D":
                 await self.set_down_rw(reader, writer)
+                return "D", None
             case "P":
                 writer.write(b"P")
                 await writer.drain()
@@ -137,34 +138,28 @@ class TCPServer:
                 self.log.warning(f"Unknown code: {code}")
                 self.log.warning("Report about that!")
                 writer.close()
-        return False, None
+        return "E", None
 
     async def handle_client(self, reader, writer):
-        while self.run:
         self._connections.add(writer)
         try:
             ip = writer.get_extra_info('peername')[0]
             if self.rl.is_banned(ip):
                 await self.rl.notify(ip, writer)
                 writer.close()
-                    break
             data = await reader.read(1)
             if not data:
-                    break
+                return
             code = data.decode()
             self.log.debug(f"Received {code!r} from {writer.get_extra_info('sockname')!r}")
-                # task = asyncio.create_task(self.handle_code(code, reader, writer))
+            _type, cl = await self.handle_code(code, reader, writer)
-                # await asyncio.wait([task], return_when=asyncio.FIRST_EXCEPTION)
+            self.log.debug(f"[{_type}] cl returned: {cl}")
-                _, cl = await self.handle_code(code, reader, writer)
-                self.log.debug(f"cl returned: {cl}")
             if cl:
                 await cl._remove_me()
-                break
         except Exception as e:
             self.log.error("Error while handling connection...")
             self.log.exception(e)
             traceback.print_exc()
-                break
 
     async def start(self):
         self.log.debug("Starting TCP server.")
@@ -172,17 +167,12 @@ class TCPServer:
         try:
             self.server = await asyncio.start_server(self.handle_client, self.host, self.port,
                                                      backlog=int(config.Game["players"] * 4))
-            self.log.debug(f"TCP server started on {self.server.sockets[0].getsockname()!r}")
-            while True:
             async with self.server:
+                self.log.debug(f"TCP server started on {self.server.sockets[0].getsockname()!r}")
                 await self.server.serve_forever()
         except OSError as e:
             self.log.error(i18n.core_bind_failed.format(e))
             raise e
-        except KeyboardInterrupt:
-            pass
-        except ConnectionResetError as e:
-            self.log.debug(f"ConnectionResetError {e}")
         except Exception as e:
             self.log.exception(e)
             raise e

src/core/udp_server.py

@@ -6,6 +6,7 @@
 # (c) kuitoi.su 2024
 import asyncio
 import json
+import time
 
 from core import utils