async def client_connected(self, stream_reader, stream_writer):
self._logger.debug("%s: Client connected", self)
protocol = QDataStreamProtocol(stream_reader, stream_writer)
connection = self._connection_factory()
try:
await connection.on_connection_made(
protocol, Address(*stream_writer.get_extra_info('peername')))
self.connections[connection] = protocol
server.stats.gauge('user.agents.None', 1, delta=True)
while True:
message = await protocol.read_message()
with server.stats.timer('connection.on_message_received'):
await connection.on_message_received(message)
with server.stats.timer('servercontext.drain'):
await asyncio.sleep(0)
await connection.drain()
except ConnectionResetError:
pass
except ConnectionAbortedError:
pass
except TimeoutError:
pass
except asyncio.IncompleteReadError as ex:
if not stream_reader.at_eof():
self._logger.exception(ex)
except Exception as ex:
self._logger.exception(ex)
finally:
del self.connections[connection]
server.stats.gauge('user.agents.{}'.format(connection.user_agent),
-1,
delta=True)
protocol.writer.close()
await connection.on_connection_lost()
def unix_protocol(unix_srv, event_loop):
(reader, writer) = event_loop.run_until_complete(
asyncio.open_unix_connection('/tmp/test.sock')
)
protocol = QDataStreamProtocol(reader, writer)
yield protocol
protocol.close()
def test_serverside_abort(loop, mock_context, mock_server):
(reader, writer) = yield from asyncio.open_connection(*mock_context.sockets[0].getsockname())
proto = QDataStreamProtocol(reader, writer)
proto.send_message({"some_junk": True})
yield from writer.drain()
yield from asyncio.sleep(0.1)
mock_server.on_connection_lost.assert_any_call()
async def test_serverside_abort(event_loop, mock_context, mock_server):
srv, ctx = mock_context
(reader,
writer) = await asyncio.open_connection(*srv.sockets[0].getsockname())
proto = QDataStreamProtocol(reader, writer)
await proto.send_message({"some_junk": True})
await exhaust_callbacks(event_loop)
mock_server.on_connection_lost.assert_any_call()
def connect_client(server):
return QDataStreamProtocol(*(yield from asyncio.open_connection(
*server.sockets[0].getsockname())))
async def connect_client(server) -> QDataStreamProtocol:
return QDataStreamProtocol(
*(await asyncio.open_connection(*server.sockets[0].getsockname()))
)
def protocol(reader, writer):
return QDataStreamProtocol(reader, writer)
def mock_protocol():
return mock.create_autospec(QDataStreamProtocol(mock.Mock(), mock.Mock()))
async def unix_protocol(unix_srv):
(reader, writer) = await asyncio.open_unix_connection("/tmp/test.sock")
protocol = QDataStreamProtocol(reader, writer)
yield protocol
await protocol.close()
async def connect(self, host, port):
self.proto = QDataStreamProtocol(
*(await asyncio.open_connection(host, port)))
