Veuillez expliquer “la Tâche a été détruit, mais il est en attente!”

Python 3.4.2

Je suis en train d'apprendre asyncio et je l'utilise pour la permanence d'écouter de la CIB en bus, tandis que gbulb à l'écoute de la dbus.

Quelques remarques:

J'ai donc créé une fonction listen_to_ipc_channel_layer que la permanence d'écoute pour les messages entrants sur la CIB canal et passe le message à un message_handler.

Je suis également à l'écoute de SIGTERM et SIGINT. Alors quand j'ai envoyer un signal SIGTERM à l'python processus en cours d'exécution le code que vous trouverez au bas, le script doit se terminer normalement.

Le problème

... Je vais avoir est l'avertissement suivant:

got signal 15: exit
Task was destroyed but it is pending!
task: <Task pending coro=<listen_to_ipc_channel_layer() running at /opt/mainloop-test.py:23> wait_for=<Future cancelled>>

Process finished with exit code 0

... avec le code suivant:

import asyncio
import gbulb
import signal
import asgi_ipc as asgi

def main():
    asyncio.async(listen_to_ipc_channel_layer())
    loop = asyncio.get_event_loop()

    for sig in (signal.SIGINT, signal.SIGTERM):
        loop.add_signal_handler(sig, ask_exit)

    # Start listening on the Linux IPC bus for incoming messages
    loop.run_forever()
    loop.close()

@asyncio.coroutine
def listen_to_ipc_channel_layer():
    """Listens to the Linux IPC bus for messages"""
    while True:
        message_handler(message=channel_layer.receive(["my_channel"]))
        try:
            yield from asyncio.sleep(0.1)
        except asyncio.CancelledError:
            break

def ask_exit():
    loop = asyncio.get_event_loop()
    for task in asyncio.Task.all_tasks():
        task.cancel()
    loop.stop()


if __name__ == "__main__":
    gbulb.install()
    # Connect to the IPC bus
    channel_layer = asgi.IPCChannelLayer(prefix="my_channel")
    main()

Encore je ne comprends que très peu de asyncio, mais je pense que je sais ce qui se passe. En attendant yield from asyncio.sleep(0.1) le gestionnaire de signal pris la SIGTERM et dans ce processus, il appelle task.cancel().

Question jeté dans: Ne devrait pas déclencher la CancelledError dans le while True: boucle? (Parce qu'il ne l'est pas, mais c'est comme ça que je comprends "L'appel de l'annuler() va lancer une CancelledError à la enveloppé coroutine").

Finalement loop.stop() est appelé, ce qui arrête la boucle, sans attendre que soit yield from asyncio.sleep(0.1) pour retourner un résultat ou même l'ensemble de la coroutine listen_to_ipc_channel_layer.

S'il vous plaît corrigez-moi si je me trompe.

Je pense que la seule chose que je dois faire est de faire de mon programme d'attendre le yield from asyncio.sleep(0.1) pour retourner un résultat et/ou coroutine de sortir le tout en boucle et terminer.

Je crois que je confonds beaucoup de choses. Merci de m'aider à faire ces choses afin que je puisse comprendre comment gracieusement fermer la boucle d'événement sans avertissement.

OriginalL'auteur Daniel | 2016-11-30

Le problème vient de la fermeture de la boucle immédiatement après l'annulation de tâches. Comme le annuler() les docs de l'état

"Cela prend des dispositions pour une CancelledError d'être jeté dans le enveloppés coroutine sur le prochain cycle par la boucle d'événements."

Prendre cet extrait de code:

import asyncio
import signal


async def pending_doom():
    await asyncio.sleep(2)
    print(">> Cancelling tasks now")
    for task in asyncio.Task.all_tasks():
        task.cancel()

    print(">> Done cancelling tasks")
    asyncio.get_event_loop().stop()


def ask_exit():
    for task in asyncio.Task.all_tasks():
        task.cancel()


async def looping_coro():
    print("Executing coroutine")
    while True:
        try:
            await asyncio.sleep(0.25)
        except asyncio.CancelledError:
            print("Got CancelledError")
            break

        print("Done waiting")

    print("Done executing coroutine")
    asyncio.get_event_loop().stop()


def main():
    asyncio.async(pending_doom())
    asyncio.async(looping_coro())

    loop = asyncio.get_event_loop()
    for sig in (signal.SIGINT, signal.SIGTERM):
        loop.add_signal_handler(sig, ask_exit)

    loop.run_forever()

    # I had to manually remove the handlers to
    # avoid an exception on BaseEventLoop.__del__
    for sig in (signal.SIGINT, signal.SIGTERM):
        loop.remove_signal_handler(sig)


if __name__ == '__main__':
    main()

Avis ask_exit annule les tâches mais n'est pas stop la boucle, sur le prochain cycle de looping_coro() l'arrête. La sortie si vous annulez c'est:

Executing coroutine
Done waiting
Done waiting
Done waiting
Done waiting
^CGot CancelledError
Done executing coroutine

Avis comment pending_doom annule et arrête la boucle immédiatement après. Si vous le laisser fonctionner jusqu'à ce que le pending_doom coroutines se réveille du sommeil, vous pouvez voir le message d'avertissement que vous obtenez:

Executing coroutine
Done waiting
Done waiting
Done waiting
Done waiting
Done waiting
Done waiting
Done waiting
>> Cancelling tasks now
>> Done cancelling tasks
Task was destroyed but it is pending!
task: <Task pending coro=<looping_coro() running at canceling_coroutines.py:24> wait_for=<Future cancelled>>

À propos de l'exception relative aux gestionnaires de signaux: Vous pouvez également éviter cette exception en appelant loop.close() à la fin.

OriginalL'auteur Yeray Diaz Diaz

Le sens de la question est que une boucle n'a pas le temps de terminer toutes les tâches.

Ceci arrange pour un CancelledError d'être jeté dans le enveloppés coroutine sur le cycle suivant par la boucle d'événements.

Il n'y a aucune chance de faire un "nouveau cycle" de la boucle dans votre approche. Pour le faire correctement, vous devez déplacer un arrêt de l'exploitation à un espace non-cyclique coroutine à donner votre boucle une chance à la fin.

Deuxième chose importante est CancelledError sensibilisation.

À La Différence De L'Avenir.annuler(), cela ne garantit pas que la tâche sera annulé: l'exception peut-être attrapé et a agi en conséquence, le fait de retarder l'annulation de la tâche ou de l'empêcher complètement l'annulation. La tâche peut également retourner une valeur ou d'élever une autre exception.

Immédiatement après cette méthode est appelée, annulé() ne renvoie pas Vrai (sauf si la tâche a déjà été annulée). Une tâche sera marqué comme annulée lorsque le enveloppés coroutine se termine avec un CancelledError exception (même s'annuler() n'a pas été appelé).

Donc, après le nettoyage de votre coroutine doit soulever CancelledError à être marqué comme annulée.

À l'aide d'un extra coroutine pour arrêter la boucle n'est pas un problème car elle n'est pas cyclique, et doit être fait immédiatement après l'exécution.

def main():                                              
    loop = asyncio.get_event_loop()                      
    asyncio.ensure_future(listen_to_ipc_channel_layer()) 

    for sig in (signal.SIGINT, signal.SIGTERM):          
        loop.add_signal_handler(sig, ask_exit)           
    loop.run_forever()                                   
    print("Close")                                       
    loop.close()                                         


@asyncio.coroutine                                       
def listen_to_ipc_channel_layer():                       
    while True:                                          
        try:                                             
            print("Running")                                 
            yield from asyncio.sleep(0.1)                
        except asyncio.CancelledError as e:              
            print("Break it out")                        
            raise e # Raise a proper error


# Stop the loop concurrently           
@asyncio.coroutine                                       
def exit():                                              
    loop = asyncio.get_event_loop()                      
    print("Stop")                                        
    loop.stop()                                          


def ask_exit():                          
    for task in asyncio.Task.all_tasks():
        task.cancel()                    
    asyncio.ensure_future(exit())        


if __name__ == "__main__":               
    main()

OriginalL'auteur I159

Vous devez vous connecter pour publier un commentaire.