Eventlet A better way to write network applications

[Update: Based on feedback from Sergey and others that this conversion process is too wordy, we decided to reinstate the convenience methods but with a better API.  See it here.]

The original Eventlet API came packed with socket convenience methods that did common socket tasks in a single line.  These were pretty convenient and got a lot of use, but unfortunately had a number of problems that caused us to decide to remove them.  The most basic reason is that they needlessly expanded the Eventlet API and confused people about whether the “true” way was the convenience method, or the socket module.

Now they’re deprecated, and we’re in the process of migrating applications and tests onto the real APIs.  Here’s some quick transition help.  (Note that I only tested these by verifying that they didn’t give interpreter errors when run; I believe that they work as intended, but running that level of verification would have meant this post wouldn’t have gotten written.)

tcp_listener

This convenience function creates a listening socket bound to a specified address.  You can replace code that looks like this:

  from eventlet import api
  sock = api.tcp_listener(('localhost', 9010))

with this:

  from eventlet.green import socket
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1)
  sock.bind(('localhost', 9010))
  sock.listen(50)

Yes, it’s longer, and it’s uglier, but it does have the advantage of being perfectly congruent with the standard Python socket library.

connect_tcp

The most common use case ever, connecting to a server, is accomplished with this method.  Here’s the convenience code:

  from eventlet import api
  sock = api.connect_tcp(('eventlet.net', 80))

If you’re running Python 2.6, you’re in luck, because you can use a standard function that’s just as convenient:

  from eventlet.green import socket
  sock = socket.create_connection(('eventlet.net', 80))

If you’re using Python 2.5 or earlier, it’s a little less convenient, but not too bad:

  from eventlet.green import socket
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.connect(('eventlet.net', 80))

ssl_listener

This one’s a bit of a doozy, because one of the conveniences provided by this function is that the caller doesn’t have to know whether they’re using PyOpenSSL or 2.6′s ssl module.  As we deprecate it, the caller now has to know which of those two options they’re using.  Here’s the old code:

  from eventlet import api
  sock = api.ssl_listener(('localhost', 443), '/tmp/server.crt',
                          '/tmp/server.key')

And the new, using Python 2.6:

  from eventlet.green import socket, ssl
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1)
  sock.bind(('localhost', 80443))
  sock.listen(50)
  sock = ssl.wrap_socket(sock,
    keyfile='/tmp/server.key',
    certfile='/tmp/server.crt',
    server_side=True)

Using PyOpenSSL (hoo boy, is this library wordy):

  from eventlet.green import socket
  from eventlet.green.OpenSSL import SSL
  sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR, 1)
  sock.bind(('localhost', 80443))
  sock.listen(50)
  context = SSL.Context(SSL.SSLv23_METHOD)
  context.use_certificate_file('/tmp/server.crt')
  context.use_privatekey_file('/tmp/server.key')
  context.set_verify(SSL.VERIFY_NONE, lambda *x: True)
  sock = SSL.Connection(context, sock)
  sock.set_accept_state()

That’s all of the convenience methods, deconstructed!  Hopefully you can see how not having the equivalent of all this logic in Eventlet makes it easier to maintain and support.