async def read_json_line(reader: StreamReader) -> Any:
while True:
line = await reader.readline()
if line:
logging.debug(f"read line from socket: {line!r}")
try:
return json.loads(line.decode("utf-8").strip())
except (ValueError, UnicodeDecodeError):
logging.warning("invalid JSON received")
if reader.at_eof():
raise DisconnectedError()
async def handle_connection(self, reader: StreamReader,
writer: StreamWriter):
peername = writer.get_extra_info('peername')
Logger.info(
'[Login Server]: Accepted connection from {}'.format(peername))
auth = AuthManager(reader, writer)
while not reader.at_eof():
response = await auth.process()
if not response:
break
Logger.warning('[Login Server]: closing...')
writer.close()
async def _reader_task(self, reader: StreamReader) -> None:
buffer = b""
while not reader.at_eof():
chunk = await reader.read(1)
if not chunk:
break
buffer += chunk
try:
byte_count, channel_id, frame = unmarshal(buffer)
except UnmarshalingException:
continue
else:
buffer = b""
_logger.debug(f"<- {frame.name} {channel_id}")
await self.dispatch_frame(frame, channel_id)
class ControlledConnection:
def __init__(self, limit=100000000):
self._reader = StreamReader(limit)
self._mock_write_data = b""
self._closed = False
self._closed_by_us = False
def _feed_data(self, data):
self._reader.feed_data(data)
def _feed_eof(self):
self._reader.feed_eof()
def _get_mock_write_data(self):
return self._mock_write_data
def _check_eof(self):
if self._reader.at_eof():
self._closed = True
async def read(self, size):
self._check_eof()
try:
return await self._reader.read(min(size, 100))
except Exception:
self._closed = True
raise MalformedDataError
async def readuntil(self, delim):
self._check_eof()
try:
return await self._reader.readuntil(delim)
except Exception:
self._closed = True
raise MalformedDataError
async def readexactly(self, amount):
self._check_eof()
try:
return await self._reader.readexactly(amount)
except Exception:
self._closed = True
raise MalformedDataError
async def write(self, data):
self._mock_write_data += data
return not self._closed
async def add_header(self, header):
pass
def close(self):
self._closed = True
self._closed_by_us = True
async def wait_closed(self):
while not self._closed:
await asyncio.sleep(1)
def closed_by_us(self):
return self._closed_by_us
