def cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None: """Cancels all tasks in a loop. Parameters ---------- loop: :class:`asyncio.AbstractEventLoop` Event loop to cancel tasks in. """ try: to_cancel = asyncio.all_tasks(loop) except AttributeError: # py < 3.7 to_cancel = asyncio.Task.all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete( asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)) for task in to_cancel: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ 'message': 'Unhandled exception during runner shutdown', 'exception': task.exception(), 'task': task })
def _cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None: if sys.version_info >= (3, 7): to_cancel = asyncio.all_tasks(loop) else: to_cancel = [t for t in asyncio.Task.all_tasks(loop) if not t.done()] if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete( asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)) # temporary shut up the logger until aiohttp will be fixed # the message scares people :) return for task in to_cancel: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ "message": "unhandled exception during asyncio.run() shutdown", "exception": task.exception(), "task": task, })
def _cancel_all_tasks_with_timeout(loop: asyncio.AbstractEventLoop, timeout: int) -> None: """Adapted _cancel_all_tasks from python 3.9 with a timeout.""" to_cancel = asyncio.all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete(asyncio.wait(to_cancel, timeout=timeout)) for task in to_cancel: if task.cancelled(): continue if not task.done(): _LOGGER.warning( "Task could not be canceled and was still running after shutdown: %s", task, ) continue if task.exception() is not None: loop.call_exception_handler({ "message": "unhandled exception during shutdown", "exception": task.exception(), "task": task, })
def _cancel_all_tasks(loop: AbstractEventLoop) -> None: """Cancels all tasks the supplied event loop is running :param loop: The event loop to use """ to_cancel = tasks.all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete( tasks.gather(*to_cancel, loop=loop, return_exceptions=True)) for task in to_cancel: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ "message": "unhandled exception during run_automation() shutdown", "exception": task.exception(), "task": task, })
def _shutdown_tasks(loop: asyncio.AbstractEventLoop) -> None: """Завершение в случае ошибки. После ошибки происходит отмена всех заданий, чтобы не захламлять сообщение об ошибке множеством сообщений, о том, что результат выполнения задания не был awaited. Идея кода позаимствована из реализации asyncio.app. """ to_cancel = asyncio.all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete(asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)) for canceled_task in to_cancel: if canceled_task.cancelled(): continue if canceled_task.exception() is not None: loop.call_exception_handler( { "message": "unhandled EventBus exception", "exception": canceled_task.exception(), "task": canceled_task, }, ) loop.run_until_complete(loop.shutdown_asyncgens()) loop.run_until_complete(loop.shutdown_default_executor())
def _cancel_all_tasks( loop: asyncio.AbstractEventLoop, ignored_exceptions: Optional[Set[Type[Exception]]] = None, ) -> None: """ Cancel all tasks on the given event loop. :param loop: The loop to cancel all tasks on :param ignored_exceptions: The set of exceptions classes to silently ignore :return: None """ to_cancel = asyncio.Task.all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete( asyncio.tasks.gather(*to_cancel, loop=loop, return_exceptions=True)) for task in to_cancel: if task.cancelled(): continue if task.exception() is not None: exception = task.exception() if ignored_exceptions and any( isinstance(exception, exception_type) for exception_type in ignored_exceptions): continue loop.call_exception_handler({ "message": "unhandled exception during asyncio.run() shutdown", "exception": exception, "task": task, })
def default_araise(exc: Exception, *, loop: AbstractEventLoop) -> bool: loop.call_exception_handler( { "message": f"Unhandled error propagated through {AnonymousObserver.__qualname__}", "exception": exc, } ) return False
async def test_asyncio_error_handler( client: TestClient, loop: asyncio.AbstractEventLoop, ) -> None: assert client.app.frozen context = { "message": "Error message", } with patch.object(app_logger, "warning") as warning: loop.call_exception_handler(context) message = "Caught asyncio exception: {message}".format_map(context) warning.assert_called_with(message)
def _cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None: tasks = [task for task in asyncio.all_tasks(loop) if not task.done()] if not tasks: return for task in tasks: task.cancel() loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True)) for task in tasks: if not task.cancelled() and task.exception() is not None: loop.call_exception_handler({ "message": "unhandled exception during shutdown", "exception": task.exception(), "task": task, })
def _cancel_tasks(to_cancel: Set["asyncio.Task[Any]"], loop: asyncio.AbstractEventLoop) -> None: if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True)) for task in to_cancel: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ "message": "unhandled exception during asyncio.run() shutdown", "exception": task.exception(), "task": task, })
def _cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None: to_cancel = asyncio.all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True)) for task in to_cancel: if task.cancelled(): continue if (exception := task.exception()) is not None: loop.call_exception_handler({ "message": "unhandled exception during shutdown", "exception": exception, "task": task, })
def _cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None: to_cancel = all_tasks(loop) if not to_cancel: return for task in to_cancel: task.cancel() loop.run_until_complete( asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)) for task in to_cancel: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ 'message': 'unhandled exception during asyncio.run() shutdown', 'exception': task.exception(), 'task': task, })
def _cancel_tasks(loop: asyncio.AbstractEventLoop) -> None: tasks = {t for t in asyncio.all_tasks(loop=loop) if not t.done()} if not tasks: return log.info('Cleaning up after %d tasks.', len(tasks)) for task in tasks: task.cancel() loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True)) log.info('All tasks finished cancelling.') for task in tasks: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ 'message': 'Unhandled exception during Client.run shutdown.', 'exception': task.exception(), 'task': task })
def _cancel_tasks(loop: asyncio.AbstractEventLoop) -> None: tasks = asyncio.all_tasks(loop=loop) if not tasks: return log.info(f"Cleaning up after {len(tasks)} tasks.") for task in tasks: task.cancel() loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True)) log.info("All tasks finished cancelling.") for task in tasks: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ "message": "unhandled exception during Client.run shutdown.", "exception": task.exception(), "task": task, })
def _cancel_all_tasks(loop: asyncio.AbstractEventLoop, is_current: bool) -> None: to_cancel = asyncio.all_tasks(loop) if not to_cancel: return done = threading.Event() count = len(to_cancel) def one_task_finished(future): nonlocal count count -= 1 if count == 0: done.set() for task in to_cancel: loop.call_soon_threadsafe(task.cancel) task.add_done_callback(one_task_finished) if is_current: loop.run_until_complete( wait_for( asyncio.gather(*to_cancel, loop=loop, return_exceptions=True), TIMEOUT)) else: # user was responsible for cancelling all tasks if not done.wait(timeout=3): raise TimeoutError("Could not stop event loop in time") for task in to_cancel: if task.cancelled(): continue if task.exception() is not None: loop.call_exception_handler({ "message": "unhandled exception during event loop shutdown", "exception": task.exception(), "task": task, })