mirror of
https://github.com/kuitoi/kuitoi-Server.git
synced 2025-08-17 08:15:42 +00:00
339 lines
12 KiB
Python
339 lines
12 KiB
Python
# Developed by KuiToi Dev
|
|
# File core.core.py
|
|
# Written by: SantaSpeen
|
|
# Version 0.1.6
|
|
# Licence: FPA
|
|
# (c) kuitoi.su 2023
|
|
import asyncio
|
|
import os
|
|
import time
|
|
import traceback
|
|
import zlib
|
|
from threading import Thread
|
|
|
|
import aiohttp
|
|
import uvicorn
|
|
|
|
from core import utils
|
|
from core.tcp_server import TCPServer
|
|
from core.udp_server import UDPServer
|
|
from modules.WebAPISystem import app as webapp
|
|
|
|
|
|
class Client:
|
|
|
|
def __init__(self, reader, writer, core):
|
|
self.reader = reader
|
|
self.writer = writer
|
|
self.log = utils.get_logger("client(None:0)")
|
|
self.addr = writer.get_extra_info("sockname")
|
|
self.loop = asyncio.get_event_loop()
|
|
self.Core = core
|
|
self.cid = 0
|
|
self.key = None
|
|
self.nick = None
|
|
self.roles = None
|
|
self.guest = True
|
|
self.alive = True
|
|
|
|
def _update_logger(self):
|
|
self.log.debug(f"Update logger")
|
|
self.log = utils.get_logger(f"client({self.nick}:{self.cid})")
|
|
|
|
def is_disconnected(self):
|
|
if not self.alive:
|
|
return True
|
|
res = self.writer.is_closing()
|
|
if res:
|
|
self.log.debug(f"Client Disconnected")
|
|
self.alive = False
|
|
return True
|
|
else:
|
|
self.log.debug(f"Client Alive")
|
|
self.alive = True
|
|
return False
|
|
|
|
async def kick(self, reason):
|
|
self.log.info(f"Client: \"IP: {self.addr!r}; ID: {self.cid}\" - kicked with reason: \"{reason}\"")
|
|
await self.tcp_send(b"K" + bytes(reason, "utf-8"))
|
|
# self.writer.close()
|
|
# await self.writer.wait_closed()
|
|
self.alive = False
|
|
|
|
async def tcp_send(self, data):
|
|
|
|
# TNetwork.cpp; Line: 383
|
|
# BEAMP TCP protocol sends a header of 4 bytes, followed by the data.
|
|
# [][][][][][]...[]
|
|
# ^------^^---...-^
|
|
# size data
|
|
|
|
self.log.debug(f"tcp_send({data})")
|
|
if len(data) == 10:
|
|
data += b"."
|
|
header = len(data).to_bytes(4, "little", signed=True)
|
|
self.log.debug(f'len(data) {len(data)}; send {header + data}')
|
|
self.writer.write(header + data)
|
|
await self.writer.drain()
|
|
|
|
async def recv(self):
|
|
# if not self.is_disconnected():
|
|
# self.log.debug(f"Client with {self.nick}({self.cid}) disconnected")
|
|
# return b""
|
|
header = await self.reader.read(4) # header: 4 bytes
|
|
|
|
int_header = 0
|
|
for i in range(len(header)):
|
|
int_header += header[i]
|
|
|
|
if int_header <= 0:
|
|
await self.kick("Invalid packet - header negative")
|
|
return b""
|
|
|
|
if int_header > 100 * MB:
|
|
await self.kick("Header size limit exceeded")
|
|
self.log.warn(f"Client {self.nick}({self.cid}) sent header of >100MB - "
|
|
f"assuming malicious intent and disconnecting the client.")
|
|
return b""
|
|
|
|
data = await self.reader.read(101 * MB)
|
|
self.log.debug(f"header: `{header}`; int_header: `{int_header}`; data: `{data}`;")
|
|
|
|
if len(data) != int_header:
|
|
self.log.debug(f"WARN Expected to read {int_header} bytes, instead got {len(data)}")
|
|
|
|
abg = b"ABG:"
|
|
if len(data) > len(abg) and data.startswith(abg):
|
|
data = zlib.decompress(data[len(abg):])
|
|
self.log.debug(f"ABG: {data}")
|
|
return data
|
|
return data
|
|
|
|
async def sync_resources(self):
|
|
await self.tcp_send(b"P" + bytes(f"{self.cid}", "utf-8"))
|
|
data = await self.recv()
|
|
if data.startswith(b"SR"):
|
|
await self.tcp_send(b"-") # Cannot handle mods for now.
|
|
data = await self.recv()
|
|
if data == b"Done":
|
|
await self.tcp_send(b"M/levels/" + bytes(config.Game['map'], 'utf-8') + b"/info.json")
|
|
await self.last_handle()
|
|
|
|
async def last_handle(self):
|
|
# self.is_disconnected()
|
|
self.log.debug(f"Alive: {self.alive}")
|
|
while self.alive:
|
|
data = await self.recv()
|
|
if data == b"":
|
|
if not self.alive:
|
|
break
|
|
elif self.is_disconnected():
|
|
break
|
|
else:
|
|
continue
|
|
code = data.decode()[0]
|
|
self.log.debug(f"Code: {code}, data: {data}")
|
|
match code:
|
|
case "H":
|
|
# Client connected
|
|
await self.tcp_send(b"Sn" + bytes(self.nick, "utf-8"))
|
|
case "C":
|
|
# Chat
|
|
await self.tcp_send(data)
|
|
|
|
|
|
class Core:
|
|
|
|
def __init__(self):
|
|
self.log = utils.get_logger("core")
|
|
self.loop = asyncio.get_event_loop()
|
|
self.run = False
|
|
self.direct = False
|
|
self.clients = {}
|
|
self.clients_counter = 0
|
|
self.mods_dir = "./mods"
|
|
self.mods_list = [0, ]
|
|
self.server_ip = config.Server["server_ip"]
|
|
self.server_port = config.Server["server_port"]
|
|
self.tcp = TCPServer
|
|
self.udp = UDPServer
|
|
self.web_thread = None
|
|
self.web_pool = webapp.data_pool
|
|
self.web_stop = None
|
|
|
|
self.client_major_version = "2.0"
|
|
self.BEAMP_version = "3.2.0"
|
|
|
|
def get_client(self, sock=None, cid=None):
|
|
if cid:
|
|
return self.clients.get(cid)
|
|
if sock:
|
|
return self.clients.get(sock.getsockname())
|
|
|
|
def insert_client(self, client):
|
|
self.log.debug(f"Inserting client: {client.cid}")
|
|
self.clients.update({client.cid: client, client.nick: client})
|
|
|
|
def create_client(self, *args, **kwargs):
|
|
client = Client(*args, **kwargs)
|
|
self.clients_counter += 1
|
|
client.id = self.clients_counter
|
|
client._update_logger()
|
|
self.log.debug(f"Create client: {client.cid}; clients_counter: {self.clients_counter}")
|
|
return client
|
|
|
|
async def check_alive(self):
|
|
await asyncio.sleep(5)
|
|
self.log.debug(f"Checking if clients is alive")
|
|
for cl in self.clients.values():
|
|
d = await cl.is_disconnected()
|
|
if d:
|
|
self.log.debug(f"Client ID: {cl.id} died...")
|
|
|
|
@staticmethod
|
|
def start_web():
|
|
global uvserver
|
|
uvconfig = uvicorn.Config("modules.WebAPISystem.app:web_app",
|
|
host=config.WebAPI["server_ip"],
|
|
port=config.WebAPI["server_port"],
|
|
loop="asyncio")
|
|
uvserver = uvicorn.Server(uvconfig)
|
|
webapp.uvserver = uvserver
|
|
uvserver.run()
|
|
|
|
@staticmethod
|
|
async def stop_me():
|
|
while webapp.data_run[0]:
|
|
await asyncio.sleep(1)
|
|
raise KeyboardInterrupt
|
|
|
|
# noinspection SpellCheckingInspection,PyPep8Naming
|
|
async def authenticate(self, test=False):
|
|
if config.Auth["private"] or self.direct:
|
|
if test:
|
|
self.log.info(f"Server runnig in Direct connect mode.")
|
|
self.direct = True
|
|
return
|
|
|
|
BEAM_backend = ["backend.beammp.com", "backup1.beammp.com", "backup2.beammp.com"]
|
|
modlist = ""
|
|
for mod in self.mods_list:
|
|
if type(mod) == int:
|
|
continue
|
|
modlist += f"/{os.path.basename(mod['path'])};"
|
|
modstotalsize = self.mods_list[0]
|
|
modstotal = len(self.mods_list) - 1
|
|
while self.run:
|
|
data = {"uuid": config.Auth["key"], "players": len(self.clients), "maxplayers": config.Game["players"],
|
|
"port": config.Server["server_port"], "map": f"/levels/{config.Game['map']}/info.json",
|
|
"private": config.Auth['private'], "version": self.BEAMP_version, "clientversion": self.client_major_version,
|
|
"name": config.Server["name"], "modlist": modlist, "modstotalsize": modstotalsize,
|
|
"modstotal": modstotal, "playerslist": "", "desc": config.Server['description'], "pass": False}
|
|
self.log.debug(f"Auth: data {data}")
|
|
|
|
# Sentry?
|
|
ok = False
|
|
body = {}
|
|
code = 0
|
|
for server_url in BEAM_backend:
|
|
url = "https://" + server_url + "/heartbeat"
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post(url, data=data, headers={"api-v": "2"}) as response:
|
|
code = response.status
|
|
body = await response.json()
|
|
self.log.debug(f"Auth: code {code}, body {body}")
|
|
ok = True
|
|
break
|
|
except Exception as e:
|
|
self.log.debug(f"Auth: Error `{e}` while auth with `{server_url}`")
|
|
continue
|
|
|
|
if ok:
|
|
if not (body.get("status") is not None and
|
|
body.get("code") is not None and
|
|
body.get("msg") is not None):
|
|
self.log.error("Missing/invalid json members in backend response")
|
|
raise KeyboardInterrupt
|
|
|
|
if test:
|
|
status = body.get("status")
|
|
msg = body.get("msg")
|
|
if status == "2000":
|
|
self.log.info(f"Authenticated! {msg}")
|
|
elif status == "200":
|
|
self.log.info(f"Resumed authenticated session. {msg}")
|
|
else:
|
|
self.log.error(f"Backend REFUSED the auth key. Reason: "
|
|
f"{msg or 'Backend did not provide a reason'}")
|
|
self.log.info(f"Server still runnig, but only in Direct connect mode.")
|
|
self.direct = True
|
|
else:
|
|
self.direct = True
|
|
if test:
|
|
self.log.error("Cannot auth...")
|
|
if not config.Auth['private']:
|
|
raise KeyboardInterrupt
|
|
if test:
|
|
self.log.info(f"Server still runnig, but only in Direct connect mode.")
|
|
|
|
if test:
|
|
return ok
|
|
|
|
await asyncio.sleep(5)
|
|
|
|
async def main(self):
|
|
try:
|
|
self.run = True
|
|
self.tcp = self.tcp(self, self.server_ip, self.server_port)
|
|
self.udp = self.udp(self, self.server_ip, self.server_port)
|
|
|
|
# WebApi Start
|
|
if config.WebAPI["enabled"]:
|
|
self.log.debug("Initializing WebAPI...")
|
|
web_thread = Thread(target=self.start_web)
|
|
web_thread.start()
|
|
self.web_thread = web_thread
|
|
self.web_stop = webapp._stop
|
|
|
|
# Mods handler
|
|
self.log.debug("Listing mods..")
|
|
if not os.path.exists(self.mods_dir):
|
|
os.mkdir(self.mods_dir)
|
|
for file in os.listdir(self.mods_dir):
|
|
path = os.path.join(self.mods_dir, file).replace("\\", "/")
|
|
if os.path.isfile(path) and path.endswith(".zip"):
|
|
size = os.path.getsize(path)
|
|
self.mods_list.append({"path": path, "size": size})
|
|
self.mods_list[0] += size
|
|
self.log.debug(f"mods_list: {self.mods_list}")
|
|
lmods = len(self.mods_list) - 1
|
|
if lmods > 0:
|
|
self.log.info(f"Loaded {lmods} mods: {round(self.mods_list[0] / MB, 2)}mb")
|
|
|
|
await self.authenticate(True)
|
|
tasks = [self.tcp.start(), self.udp.start(), console.start(),
|
|
self.stop_me(), self.authenticate(),] # self.check_alive()
|
|
t = asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
|
|
|
|
self.log.info(i18n.start)
|
|
ev.call_event("on_started")
|
|
await t
|
|
# Wait the end.
|
|
except Exception as e:
|
|
self.log.error(f"Exception: {e}")
|
|
traceback.print_exc()
|
|
except KeyboardInterrupt:
|
|
pass
|
|
finally:
|
|
self.run = False
|
|
|
|
def start(self):
|
|
asyncio.run(self.main())
|
|
|
|
def stop(self):
|
|
self.run = False
|
|
self.log.info(i18n.stop)
|
|
asyncio.run(self.web_stop())
|
|
exit(0)
|