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()