Deadlock when connection close on app teardown.

[heckad]

In rpc method in channel you acquire self.lock and on handle asyncio.TimeoutError you call self.close(e) wich call rpc which by that time had already captured lock. This leads to the deadlock.

import asyncio

import aio_pika


def work_1():
    async def inner():
        await asyncio.sleep(10)

    return asyncio.create_task(inner(), name='work-1')


def work_2():
    async def inner():
        await asyncio.sleep(2)
        exit(-1)

    return asyncio.create_task(inner(), name='work-2')


async def work():
    await asyncio.wait([
        work_1(), work_2()
    ])


async def main():
    connection: aio_pika.RobustConnection = await aio_pika.connect_robust(
        "amqp://guest:guest@localhost"
    )

    async with connection:
        async with connection.channel() as chanel:
            try:
                await work()
            finally:
                await asyncio.sleep(1)


from asyncio import coroutines
from asyncio import events
from asyncio import tasks


def run(main, *, debug=False):
    """Execute the coroutine and return the result.

    This function runs the passed coroutine, taking care of
    managing the asyncio event loop and finalizing asynchronous
    generators.

    This function cannot be called when another asyncio event loop is
    running in the same thread.

    If debug is True, the event loop will be run in debug mode.

    This function always creates a new event loop and closes it at the end.
    It should be used as a main entry point for asyncio programs, and should
    ideally only be called once.

    Example:

        async def main():
            await asyncio.sleep(1)
            print('hello')

        asyncio.run(main())
    """
    if events._get_running_loop() is not None:
        raise RuntimeError(
            "asyncio.run() cannot be called from a running event loop")

    if not coroutines.iscoroutine(main):
        raise ValueError("a coroutine was expected, got {!r}".format(main))

    loop = events.new_event_loop()
    try:
        events.set_event_loop(loop)
        loop.set_debug(debug)
        return loop.run_until_complete(main)
    finally:
        try:
            _cancel_all_tasks(loop)
            loop.run_until_complete(loop.shutdown_asyncgens())
        finally:
            events.set_event_loop(None)
            loop.close()


def _cancel_all_tasks(loop):
    to_cancel = tasks.all_tasks(loop)
    if not to_cancel:
        return

    tasks1 = sorted(list(to_cancel), key=lambda t: t.get_name())

    for task in reversed(tasks1):
        task.cancel()

        try:
            print("Stop task:", task.get_name())
            res = loop.run_until_complete(task)
        except asyncio.CancelledError:
            pass
        else:
            print(res)

        print("Complete stop task:", task.get_name())

    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 asyncio.run() shutdown',
                'exception': task.exception(),
                'task': task,
            })


if __name__ == '__main__':
    run(main())