Exemplo n.º 1
0
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,
            })
Exemplo n.º 3
0
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,
            })
Exemplo n.º 5
0
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())
Exemplo n.º 6
0
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,
            })
Exemplo n.º 7
0
def default_araise(exc: Exception, *, loop: AbstractEventLoop) -> bool:
    loop.call_exception_handler(
        {
            "message": f"Unhandled error propagated through {AnonymousObserver.__qualname__}",
            "exception": exc,
        }
    )
    return False
Exemplo n.º 8
0
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)
Exemplo n.º 9
0
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,
            })
Exemplo n.º 10
0
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,
            })
Exemplo n.º 11
0
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,
            })
Exemplo n.º 12
0
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,
            })
Exemplo n.º 13
0
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,
            })
Exemplo n.º 14
0
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
            })
Exemplo n.º 15
0
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,
            })
Exemplo n.º 16
0
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,
            })