async def handle_connection(self):
logger.log_debug("District connected.")
self.send_raw_message("AUTH#{}".format(
self.server.config["district_password"]))
while True:
data = await self.reader.readuntil(b"\r\n")
if not data:
return
raw_msg = data.decode()[:-2]
logger.log_debug("[DISTRICT][INC][RAW]{}".format(raw_msg))
cmd, *args = raw_msg.split("#")
if cmd == "GLOBAL":
glob_name = "{}[{}:{}][{}]".format("<dollar>G", args[1],
args[2], args[3])
if args[0] == "1":
glob_name += "[M]"
self.server.send_all_cmd_pred(
"CT",
glob_name,
args[4],
pred=lambda x: not x.muted_global)
elif cmd == "NEED":
need_msg = "=== Cross Advert ===\r\n{} at {} in {} [{}] needs {}\r\n====================".format(
args[1], args[0], args[2], args[3], args[4])
self.server.send_all_cmd_pred(
"CT",
"{}".format(self.server.config["hostname"]),
need_msg,
pred=lambda x: not x.muted_adverts,
)
async def handle_connection(self):
print(logger.log_debug("Master server connected."))
await self.send_server_info()
while True:
data = await self.reader.readuntil(b"#%")
if not data:
return
raw_msg = data.decode()[:-2]
cmd, *args = raw_msg.split("#")
if cmd != "CHECK" and cmd != "PONG":
logger.log_debug("[MASTERSERVER][INC][RAW]{}".format(raw_msg))
if cmd == "CHECK":
await self.send_raw_message("PING#%")
elif cmd == "NOSERV":
await self.send_server_info()
async def connect(self):
loop = asyncio.get_event_loop()
while True:
try:
self.reader, self.writer = await asyncio.open_connection(
self.server.config["masterserver_ip"],
self.server.config["masterserver_port"],
loop=loop,
)
await self.handle_connection()
except (ConnectionRefusedError, TimeoutError):
pass
except (ConnectionResetError, asyncio.IncompleteReadError):
self.writer = None
self.reader = None
finally:
logger.log_debug(
"Couldn't connect to the master server, retrying in 30 seconds."
)
await asyncio.sleep(30)
def data_received(self, data):
""" Handles any data received from the network.
Receives data, parses them into a command and passes it
to the command handler.
:param data: bytes of data
"""
# try to decode as utf-8, ignore any erroneous characters
self.buffer += data.decode("utf-8", "ignore")
if len(self.buffer) > 8192:
self.client.disconnect()
for msg in self.get_messages():
if len(msg) < 2:
self.client.disconnect()
return
try:
if self.server.config["debug"]:
print(logger.log_debug(f"[RCV]{msg}", self.client))
cmd, *args = msg.split("#")
self.net_cmd_dispatcher[cmd](self, args)
except KeyError:
return
def start(self):
loop = asyncio.get_event_loop()
bound_ip = "0.0.0.0"
if self.config["local"]:
bound_ip = "127.0.0.1"
ao_server_crt = loop.create_server(lambda: AOProtocol(self), bound_ip,
self.config["port"])
ao_server = loop.run_until_complete(ao_server_crt)
if self.config["use_websockets"]:
ao_server_ws = websockets.serve(new_websocket_client(self),
bound_ip,
self.config["websocket_port"])
asyncio.ensure_future(ao_server_ws)
print(logger.log_debug("WebSocket support enabled."))
if self.config["use_district"]:
self.district_client = DistrictClient(self)
asyncio.ensure_future(self.district_client.connect(), loop=loop)
print(logger.log_debug("District support enabled."))
if self.config["use_masterserver"]:
self.ms_client = MasterServerClient(self)
asyncio.ensure_future(self.ms_client.connect(), loop=loop)
print(logger.log_debug("Master server support enabled."))
print(logger.log_debug("Server started."))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
logger.log_debug("Server shutting down.")
ao_server.close()
loop.run_until_complete(ao_server.wait_closed())
loop.close()
def _send_raw_message(self, msg):
if self.server.config["debug"]:
print(logger.log_debug(f"[SND]{msg}", self))
self.network.send_raw_message(msg)