segnali asincroni con asyncio

Question

mio elaborazione modello Post utilizza il segnale post_save:

from django.core.signals import request_finished 
from django.dispatch import receiver 
from models import MyModel 
from pipeline import this_takes_forever 


@receiver(post_save, sender=MyModel) 
def my_callback(sender, **kwargs): 
    this_takes_forever(sender) 

Il this_takes_forever di routine fa IO quindi voglio rinviare per evitare il blocco della richiesta troppo.

Ho pensato che fosse un ottimo caso per il nuovo modulo asyncio. Ma ho difficoltà a prendere in considerazione l'intero processo.

Credo dovrei essere in grado di adattare il ricevitore di segnale in questo modo:

@receiver(post_save, sender=MyModel) 
def my_callback(sender, **kwargs): 
    loop = asyncio.get_event_loop() 
    loop.run_until_complete(this_takes_forever(sender)) 
    loop.close() 

fornito this_takes_forever è inoltre atto ad essere un coroutine.

@coroutine 
def this_takes_forever(instance): 
    # do something with instance 
    return instance 

Questo suona troppo magico per funzionare. Ed in effetti ferma con una AssertionError:

AssertionError at /new/ 
There is no current event loop in thread 'Thread-1'. 

Non vedo dove devo iniziare il ciclo in questo contesto. Qualcuno ha provato qualcosa del genere?

Answer 1

non ottenete alcun beneficio nel vostro caso:

@receiver(post_save, sender=MyModel) 
def my_callback(sender, **kwargs): 
    this_takes_forever(sender) 

è uguale a

@receiver(post_save, sender=MyModel) 
def my_callback(sender, **kwargs): 
    loop = asyncio.get_event_loop() 
    loop.run_until_complete(this_takes_forever(sender)) 
    loop.close() 

in termini di tempo di esecuzione. loop.run_until_complete attende la fine della chiamata di coroutine this_takes_forever(sender), in modo da ottenere la chiamata sincrona nel secondo caso e nella precedente.

Circa AssertionError: si inizia Django app in modalità multithread, ma asyncio rende ciclo di eventi di default solo il thread principale - si dovrebbe registrare nuovo loop per ogni thread creato dall'utente quando è necessario chiamare asyncio codice.

Ma, ripeto, asyncio non può risolvere il tuo particolare problema, è solo incompatibile con Django.

Il metodo standard per Django è di rinviare il codice di lungo corso nel compito di sedano (vedi http://www.celeryproject.org/)