async def test_request_response_cancellation(pipe):
server_future = create_future()
class Handler(BaseRequestHandler):
async def request_response(self, payload: Payload):
# return a future that will never complete.
return server_future
server, client = pipe
server._handler = Handler(server)
future = client.request_response(Payload())
with pytest.raises(asyncio.TimeoutError):
await asyncio.wait_for(asyncio.shield(server_future), 0.1)
assert not server_future.cancelled()
future.cancel()
with pytest.raises(asyncio.CancelledError):
await asyncio.wait_for(asyncio.shield(server_future), 0.1)
with pytest.raises(asyncio.CancelledError):
await future
async def _reconnect_listener(self):
try:
while True:
await self._connect_request_event.wait()
logger().debug('%s: Got reconnect request',
self._log_identifier())
if self._connecting:
continue
self._connecting = True
self._connect_request_event.clear()
await self._close(reconnect=True)
self._next_transport = create_future()
await self.connect()
except CancelledError:
logger().debug('%s: Asyncio task canceled: reconnect_listener',
self._log_identifier())
except Exception:
logger().error('%s: Reconnect listener',
self._log_identifier(),
exc_info=True)
finally:
self.stop_all_streams()
def to_fire_and_forget_frame(stream_id: int, payload: Payload) -> RequestFireAndForgetFrame:
frame = RequestFireAndForgetFrame()
frame.stream_id = stream_id
frame.data = payload.data
frame.metadata = payload.metadata
frame.sent_future = create_future()
return frame
def to_metadata_push_frame(metadata: bytes) -> MetadataPushFrame:
frame = MetadataPushFrame()
frame.metadata = metadata
frame.sent_future = create_future()
return frame
def _current_transport(self) -> Awaitable[Transport]:
return create_future(self._transport)
async def request_response(self, request: Payload):
await asyncio.sleep(4)
return create_future(Payload(b'response'))
async def request_response(self, payload: Payload):
return create_future(to_response_payload(payload, self._server_id))
async def request_response(self, payload: Payload) -> Awaitable[Payload]:
await asyncio.sleep(0.1) # Simulate not immediate process
date_time_format = payload.data.decode('utf-8')
formatted_date_time = datetime.now().strftime(date_time_format)
return create_future(Payload(formatted_date_time.encode('utf-8')))
async def response():
return create_future(Payload(b'result'))
async def response(composite_metadata: CompositeMetadata):
return create_future(
Payload(metadata=composite_metadata.items[0].tags[0]))
async def request_response(self,
payload: Payload) -> Awaitable[Payload]:
if not self._authenticated:
raise RSocketApplicationError("Not authenticated")
return create_future(Payload(b'response'))
async def request_response(self, payload: Payload):
return create_future(Payload(b'(client ' + payload.data + b')',
b'(client ' + payload.metadata + b')'))
async def request_response(self, payload: Payload):
future = create_future()
self.socket.request_response(payload).add_done_callback(
functools.partial(self.future_done, future))
return future
async def request_response(self, payload: Payload) -> Awaitable[Payload]:
return create_future(Payload(b'pong'))
async def request_response(self, payload: Payload) -> Future:
nonlocal response_sent
await asyncio.sleep(3)
response_sent = True
return create_future(Payload(b'response'))
async def response(payload: Payload):
return create_future(
Payload(('Response %s' % payload.data.decode()).encode()))
async def single_request_response(payload, composite_metadata):
logging.info('Got single request')
return create_future(Payload(b'single_response'))
async def response(payload: Payload,
composite_metadata: CompositeMetadata):
return create_future(
Payload(('Response %s' % payload.data.decode()).encode(),
composite_metadata.items[0].tags[0]))
async def get_last_fnf():
logging.info('Got single request')
return create_future(Payload(storage.last_fire_and_forget))
async def response(payload: dict):
return create_future(Payload(
('Response %s' % payload['key']).encode()))
async def get_last_metadata_push():
logging.info('Got single request')
return create_future(Payload(storage.last_metadata_push))
async def request_response(self,
payload: Payload) -> Awaitable[Payload]:
await asyncio.sleep(2)
return create_future(Payload(b'response'))
async def request_response2(payload,
composite_metadata) -> Awaitable[Payload]:
return create_future()
