Question

I have the following problem.

I work on a tornado based application server. Most of the code can be synchronous and the web interface does not really use any of the asynchronous facilities of Tornado.

I now have to interface to an (asynchronous) legacy backend for which I use the tornado.iostream interface to send commands. Responses to these commands are sent asynchronously, together with other periodic information, such as status updates.

The code is wrapped in a common interface that is also used for other backends.

What I want to achieve is the following:

# this is executed on initialization
self.stream.read_until_close(self.close, self.read_from_backend)

# this is called whenever data arrives on the input stream
def read_from_backend(self, data):
     if data in pending:
         # it means we got a response to a request we sent out
         del self.pending[data]
     else:
         # do something else

# this sends a request to the backend
def send_to_backend(self, data):
     self.pending[data] = True
     while data in self.pending:
          # of course this does not work
          time.sleep(1)
     return 

Of course this does not work, as time.sleep(1) will not allow read_from_backend() to run any further.

How do I solve this? I want the send_to_backend() to return only when the response is received. Is there a way I can yield control to read_from_backend without yet returning from the method?

Please note that it is difficult to do this at a in the web layer using @asynchronous and @gen.engine, because that would require a full rewrite of all requests in our web layer. Is there a way I can implement the same design pattern somewhere else?

Answer 1

I think a good idea may be to look into using gevent. By MonkeyPatching and using a simple decorator I wrote you can get very easily nice asynchronous views which are written in a synchronous manner (blocking style).

You can reuse most of the code from a previous answer of mine.

Though you may not want to use gevent for different reasons (not having it has a dependency):

Admitting that you’ve monkey patched your global process with :

from gevent import monkey; monkey.patch_all()

The above patches threads, sockets, sleep … so they go through gevent’s hub (the hub is to gevent what the ioloop is to tornado).

Once patched and by using the @gasync decorator in my previous answer your view could simply be :

class MyHandler(tornado.web.RequestHandler):
     @gasync
     def get(self):
         # Parse the input data in some fashion
         data = get_data_from_request()

         # This could be anything using python sockets, urllib ...
         backend_response = send_data_to_backend(data)

         # Write data to HTTP client
         self.write(backend_response)

         # You have to finish the response yourself since it's asynchronous
         self.finish()

I find that gevent’s simplicity and “elegance” far outweighs any advantage you would have writing async code with tornado’s ioloop.

In my case I had to use legacy code written in a synchronous fashion, so basically gevent was a life safer, all I had to do was monkey patch and write that decorator and I could use all that legacy code without any modifications.

I hope this helps.