Die Ausführung einer asynchronen hintergrund-task in Tornado

Lesen der Tornado-Dokumentation, es ist sehr klar, wie aufrufen, eine async-Funktion zum zurückgeben einer Reaktion:

class GenAsyncHandler(RequestHandler):
    @gen.coroutine
    def get(self):
        http_client = AsyncHTTPClient()
        response = yield http_client.fetch("http://example.com")
        do_something_with_response(response)
        self.render("template.html")

Was fehlt ist, wie sollte ein Anruf gemacht werden asynchron an ein hintergrund-task, die keinen Bezug zu der aktuellen Anforderung:

class GenAsyncHandler(RequestHandler):
    @gen.coroutine
    def _background_task():
        pass  # do lots of background stuff

    @gen.coroutine
    def get(self):
        _dont_care = yield self._background_task()
        self.render("template.html")

Dieser code würde funktionieren, außer, dass es läuft synchron und die Anfrage wartet, bis es fertig ist.

Was ist der Recht Weg, um asynchron aufrufen, diese Aufgabe unter sofortiger Rücksendung der aktuellen Anfrage?

InformationsquelleAutor Yuval Adam | 2014-02-27

14

Update: Seit Tornado 4.0 (Juli 2014), die unterhalb der Funktion steht in der IOLoop.spawn_callback Methode.

Leider ist es etwas schwierig. Sie brauchen, um beide zu trennen-hintergrund Aufgabe aus der aktuellen Anforderung (so dass ein Ausfall der hintergrund-tasks nicht Ergebnis in eine zufällige Ausnahme geworfen Anfrage) und sorgen dafür, dass etwas hört die hintergrund-task Ergebnis (anmelden seine Fehler, wenn nichts anderes). Dies bedeutet so etwas wie dieses:
```
from tornado.ioloop import IOLoop
from tornado.stack_context import run_in_stack_context, NullContext
IOLoop.current().add_future(run_in_stack_context(NullContext(), self._background_task),
                            lambda f: f.result())
```
Etwas wie dies wird wahrscheinlich Hinzugefügt werden, um die tornado selbst in der Zukunft.
- Hoffnung zu sehen, diese fügte sich schließlich. Vielen Dank für die ausführliche Antwort und für Ihre Arbeit mit dem tornado 🙂
InformationsquelleAutor Ben Darnell

Empfehle ich toro. Es bietet einen relativ einfachen Mechanismus für die Einrichtung eines hintergrund-Warteschlange von Aufgaben.

Den folgenden code (in queue.py zum Beispiel), startet eine einfache "Arbeiter ()", die einfach wartet, bis es ist etwas in seiner Warteschlange. Wenn Sie anrufen queue.add(function,async,*args,**kwargs) dies fügt ein Element in die Warteschlange, die aufwachen, Arbeiter (), die dann startet die Aufgabe.

Habe ich den async-parameter so, dass diese Unterstützung von hintergrund-tasks-wrapped in @gen.coroutine und solche ohne.

import toro,tornado.gen
queue = toro.Queue()
@tornado.gen.coroutine
def add(function,async,*args,**kwargs):
   item = dict(function=function,async=async,args=args,kwargs=kwargs)
   yield queue.put(item)

@tornado.gen.coroutine
def worker():
   while True:
      print("worker() sleeping until I get next item")
      item = yield queue.get()
      print("worker() waking up to process: %s" % item)
      try:
         if item['async']:
            yield item['function'](*item['args'],**item['kwargs'])
         else:
            item['function'](*item['args'],**item['kwargs'])
      except Exception as e:
         print("worker() failed to run item: %s, received exception:\n%s" % (item,e))

@tornado.gen.coroutine
def start():
   yield worker()

In Ihrem Haupt-tornado-app:

import queue
queue.start()

Und nun können Sie planen, ein Boden zurück, die Aufgabe ganz einfach:

def my_func(arg1,somekwarg=None):
   print("in my_func() with %s %s" % (arg1,somekwarg))

queue.add(my_func,False,somearg,somekwarg=someval)

InformationsquelleAutor Mike N

Ich habe eine zeitaufwändige Aufgabe in der post-Anforderung, vielleicht auch mehr als 30 Minuten brauchen, aber client benötigt Rückkehr sofort ein Ergebnis.

Erste, die ich verwendet,IOLoop.current().spawn_callback. Es funktioniert! aber! Wenn die erste Anforderung-task ausgeführt wird, wird die zweite Anforderung-task blockiert! Denn alle Aufgaben sind in Haupt-event-Schleife verwenden, wenn spawn_callback, so eine Aufgabe ist die synchrone Ausführung, andere Aufgaben blockiert.

Letzte, ich benutze tornado.gleichzeitige. Beispiel:

import datetime
import time

from tornado.ioloop import IOLoop
import tornado.web
from tornado import concurrent

executor = concurrent.futures.ThreadPoolExecutor(8)


class Handler(tornado.web.RequestHandler):

    def get(self):
        def task(arg):
            for i in range(10):
                time.sleep(1)
                print(arg, i)

        executor.submit(task, datetime.datetime.now())
        self.write('request accepted')


def make_app():
    return tornado.web.Application([
        (r"/", Handler),
    ])


if __name__ == "__main__":
    app = make_app()
    app.listen(8000, '0.0.0.0')
    IOLoop.current().start()

besuchen und http://127.0.0.1:8000, können Sie sehen, es ist ok:

2017-01-17 22:42:10.983632 0
2017-01-17 22:42:10.983632 1
2017-01-17 22:42:10.983632 2
2017-01-17 22:42:13.710145 0
2017-01-17 22:42:10.983632 3
2017-01-17 22:42:13.710145 1
2017-01-17 22:42:10.983632 4
2017-01-17 22:42:13.710145 2
2017-01-17 22:42:10.983632 5
2017-01-17 22:42:16.694966 0
2017-01-17 22:42:13.710145 3
2017-01-17 22:42:10.983632 6
2017-01-17 22:42:16.694966 1
2017-01-17 22:42:13.710145 4
2017-01-17 22:42:10.983632 7
2017-01-17 22:42:16.694966 2
2017-01-17 22:42:13.710145 5
2017-01-17 22:42:10.983632 8
2017-01-17 22:42:16.694966 3
2017-01-17 22:42:13.710145 6
2017-01-17 22:42:19.790646 0
2017-01-17 22:42:10.983632 9
2017-01-17 22:42:16.694966 4
2017-01-17 22:42:13.710145 7
2017-01-17 22:42:19.790646 1
2017-01-17 22:42:16.694966 5
2017-01-17 22:42:13.710145 8
2017-01-17 22:42:19.790646 2
2017-01-17 22:42:16.694966 6
2017-01-17 22:42:13.710145 9
2017-01-17 22:42:19.790646 3
2017-01-17 22:42:16.694966 7
2017-01-17 22:42:19.790646 4
2017-01-17 22:42:16.694966 8
2017-01-17 22:42:19.790646 5
2017-01-17 22:42:16.694966 9
2017-01-17 22:42:19.790646 6
2017-01-17 22:42:19.790646 7
2017-01-17 22:42:19.790646 8
2017-01-17 22:42:19.790646 9

Möchten allen zu helfen!

InformationsquelleAutor Legolas Bloom

2

Einfach:
```
self._background_task()
```
Den _background_task coroutine gibt eine Future ist ungelöst, bis die koroutine abgeschlossen. Wenn Sie nicht Ertrag der Future, und statt dessen einfach die nächste Zeile ausführen sofort, dann get() nicht warten _background_task fertig zu stellen.

Interessantes detail ist, dass, bis _background_task Oberflächen, pflegt Sie einen Verweis auf self. (Vergessen Sie nicht, fügen Sie self als parameter, übrigens.) Ihre RequestHandler nicht Müll gesammelt, bis nach _background_task abgeschlossen.
- Dies erweist sich als etwas schwieriger, als ich dachte, meine Aufgabe ist dabei einige nicht triviale Sachen, die nicht so leicht "asynchrone" (posix-socket-IO). Seit seiner derzeit blockieren Sie das gesamte IO-Schleife, es ist schwer zu testen, aber dies scheint die richtige Richtung, danke!
- Aber wenn Sie nicht nachgeben / warten für die Future funktioniert die Methode Körper eigentlich laufen?
InformationsquelleAutor A. Jesse Jiryu Davis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.