用龙卷风处理请求超时

Question

I have some long requests that I need to handle in my Tornado server. I'm just starting to understand the whole concept of asynchronous code with Tornado, and it seems that while this will allow more users to interact with the server while it's processing my long requests, it will not solve my problem which is request timeouts .

Asynchronous code works asynchronously in the server but the client remains synchronous, meaning that while the server can handle more requests, the client is "stuck" waiting for the response until a timeout occurs (am I wrong?)

The question is, how do I solve the browser timeouts? In other words, I'm looking for a way to make a request from the client that will return immediately but process the request in the background. When the processing is done, it should somehow inform the client.

Is there a builtin mechanism or library for that? What is the best way to handle this situation?

Answer 1

Tornado's RequestHandler can accept a POST from the client, add the task to a queue, and respond "ok I got it":

q = collections.deque()

class MyHandler(RequestHandler):
    def post(self):
        # Your code determines what work the client requests:
        task_info = parse(self.request.body)
        q.append(task_info)
        self.finish(json.dumps({'ok': 1}))

The client should generate a unique task_id and include it in the information it POSTs.

If you want a more sophisticated task queue you can check out my Toro project . Or a simpler approach is to just use a Tornado PeriodicCallback to check often if there are tasks in the queue.

So how do you inform the client that a task is done? If the client is a browser, I suggest a websocket connection. Here's Tornado's websocket documentation . When someone visits your page, some Javascript should open a websocket connection to the server. When the visitor submits a task, the Javascript first generates a task_id, subscribes for notifications about that task_id, and then it POSTs the task info to the server. Javascript:

var ws = new WebSocket("ws://localhost:8888/websocket");
ws.onmessage = function (evt) {
   alert(evt.data);
};

/* Tell the server we want to know about this task */
function subscribe(task_id) {
    ws.send(JSON.stringify({task_id: task_id}));
}

Here's the server's websocket handler:

notifiers = set()

class TaskNotifier(websocket.WebSocketHandler):
    def open(self):
        notifiers.add(self)

    def on_message(self, message):
        # Client is asking to subscribe to notifications about
        # a certain task_id.
        parsed = json.loads(message)
        self.task_id = parsed['task_id']

    def on_close(self):
        notifiers.discard(self)

Now, whenever your code pulls a task from q and completes it, it does (in Python):

for n in notifiers:
    if n.task_id == task_id:
        n.write_message('task %s done' % task_id)

Then the Javascript client in the browser detects that the task it's waiting for is complete.

Note that the client subscribes for notifications about a task before it actually submits the task to the server; this ensures no race condition, even if the server finishes the task very quickly.