def outer(): nonlocal has_timeout try: with Timeout(0.001, loop=loop): yield from asyncio.sleep(1, loop=loop) except asyncio.TimeoutError: has_timeout = True
def test_timeout_suppress_exception_chain(loop): with pytest.raises(asyncio.TimeoutError) as ctx: with Timeout(0.01, loop=loop) as t: yield from asyncio.sleep(10, loop=loop) assert t._loop is loop assert ctx.value.__suppress_context__
def test_timeout_blocking_loop(loop): @asyncio.coroutine def long_running_task(): time.sleep(0.1) return 'done' with Timeout(0.01, loop=loop): result = yield from long_running_task() assert result == 'done'
def test_timeout_finish_in_time(loop): @asyncio.coroutine def long_running_task(): yield from asyncio.sleep(0.01, loop=loop) return 'done' with Timeout(0.1, loop=loop): resp = yield from long_running_task() assert resp == 'done'
def test_timeout_disable(loop): @asyncio.coroutine def long_running_task(): yield from asyncio.sleep(0.1, loop=loop) return 'done' t0 = loop.time() with Timeout(None, loop=loop): resp = yield from long_running_task() assert resp == 'done' dt = loop.time() - t0 assert 0.09 < dt < 0.11, dt
def test_timeout_time(loop): foo_running = None start = loop.time() with pytest.raises(asyncio.TimeoutError): with Timeout(0.1, loop=loop): foo_running = True try: yield from asyncio.sleep(0.2, loop=loop) finally: foo_running = False dt = loop.time() - start assert 0.09 < dt < 0.11 assert not foo_running
def test_timeout(loop): canceled_raised = False @asyncio.coroutine def long_running_task(): try: yield from asyncio.sleep(10, loop=loop) except asyncio.CancelledError: nonlocal canceled_raised canceled_raised = True raise with pytest.raises(asyncio.TimeoutError): with Timeout(0.01, loop=loop) as t: yield from long_running_task() assert t._loop is loop assert canceled_raised, 'CancelledError was not raised'
def test_timeout_time(loop): foo_running = None start = loop.time() with pytest.raises(asyncio.TimeoutError): with Timeout(0.1, loop=loop): foo_running = True try: yield from asyncio.sleep(0.2, loop=loop) finally: foo_running = False dt = loop.time() - start if not (0.09 < dt < 0.11) and os.environ.get('APPVEYOR'): pytest.xfail('appveyor sometimes is toooo sloooow') assert 0.09 < dt < 0.11 assert not foo_running
def test_for_race_conditions(loop): fut = asyncio.Future(loop=loop) loop.call_later(0.1, fut.set_result('done')) with Timeout(0.2, loop=loop): resp = yield from fut assert resp == 'done'
def test_timeout_canceled_error_is_converted_to_timeout(loop): yield from asyncio.sleep(0, loop=loop) with pytest.raises(asyncio.CancelledError): with Timeout(0.001, loop=loop): raise asyncio.CancelledError
def test_timeout_not_relevant_exception(loop): yield from asyncio.sleep(0, loop=loop) with pytest.raises(KeyError): with Timeout(0.1, loop=loop): raise KeyError
def run(): with Timeout(0.1) as t: yield from asyncio.sleep(0.01) assert t._loop is loop
def test_raise_runtimeerror_if_no_task(loop): with pytest.raises(RuntimeError): with Timeout(0.1, loop=loop): pass
def start(self): """Start processing of incoming requests. It reads request line, request headers and request payload, then calls handle_request() method. Subclass has to override handle_request(). start() handles various exceptions in request or response handling. Connection is being closed always unless keep_alive(True) specified. """ reader = self.reader self.writer.set_tcp_nodelay(True) try: while not self._closing: message = None self._keepalive = False self._request_count += 1 self._reading_request = False payload = None # slow request timer with Timeout(max(self._slow_request_timeout, self._keepalive_timeout), loop=self._loop): # read request headers httpstream = reader.set_parser(self._request_parser) message = yield from httpstream.read() # request may not have payload try: content_length = int( message.headers.get(hdrs.CONTENT_LENGTH, 0)) except ValueError: raise errors.InvalidHeader(hdrs.CONTENT_LENGTH) from None if (content_length > 0 or message.method == hdrs.METH_CONNECT or hdrs.SEC_WEBSOCKET_KEY1 in message.headers or 'chunked' in message.headers.get( hdrs.TRANSFER_ENCODING, '')): payload = streams.FlowControlStreamReader(reader, loop=self._loop) reader.set_parser(aiohttp.HttpPayloadParser(message), payload) else: payload = EMPTY_PAYLOAD yield from self.handle_request(message, payload) if payload and not payload.is_eof(): self.log_debug('Uncompleted request.') self._closing = True else: reader.unset_parser() if not self._keepalive or not self._keepalive_timeout: self._closing = True except asyncio.CancelledError: self.log_debug('Request handler cancelled.') return except asyncio.TimeoutError: self.log_debug('Request handler timed out.') return except errors.ClientDisconnectedError: self.log_debug('Ignored premature client disconnection #1.') return except errors.HttpProcessingError as exc: yield from self.handle_error(exc.code, message, None, exc, exc.headers, exc.message) except Exception as exc: yield from self.handle_error(500, message, None, exc) finally: self._request_handler = None if self.transport is None: self.log_debug('Ignored premature client disconnection #2.') else: self.transport.close()