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