More on Python for networking: a performance comparison of different asynchronous frameworks, including Twisted and Tornado. It focuses on raw performance (it is just an HTTP echo server implemented in each platform, and tested with httpperf), so it ignores the features provided…

However, it has brought to my attention two frameworks based on libevent: Gevent and Concurrence. Gevent provides some bindings for libevent for Python, adding the use of greenlets to the equation. Concurrence goes one step further by using “Lightweight-tasks-with-message-passing approach to concurrency“, providing “an easier programming model for writing high performance network applications than existing solutions (Multi-threading, Twisted, asyncore etc).”  Concurrence can be used with the greenlets library or with ‘Stackless Python’, a branch of the standard CPython that is supposed to give better performance on multi-threading programs.

All these frameworks looks really promising if you are looking for raw performance, but I stick with Twisted for my experiments. The huge number of protocols implemented by the standard distribution, its more-than-good documentation, and all the mailing lists and blogs, make Twisted a good platform for developing networking applications, even if there are other, faster alternatives on the market.

Yesterday I found this code snippet on a DNS server made with Twisted. It just forwards the DNS queries to Google’s servers, with some optional filtering or transformation in the middle. It has been really shocking to see how easy is to make your own DNS server in Python…

Ok, ok, maybe it is not as fast as a DNS server should be, but who cares? You can put a PowerDNS server in front in recursor mode, dealing with user requests on one side while it asks and caches results from your - maybe slow - Python DNS server on the other side. And, if it is really slow, you could hide the Python server from the internet with some iptables rules, so it can only be accesible from the PowerDNS server…

from twisted.internet.protocol import Factory, Protocol

from twisted.internet import reactor

from twisted.protocols import dns

from twisted.names import client, server

class SpelDnsResolver(client.Resolver):

  def filterAnswers(self, message):

    if message.trunc:

      return self.queryTCP(message.queries).addCallback(self.filterAnswers)

    else:

      if(len(message.answers) == 0):

        query = message.queries[0]

        # code to do a dns rewrite

        return self.queryUDP('8.8.8.8').addCallback(self.filterAnswers)

    return (message.answers, message.authority, message.additional)

verbosity = 0

resolver = SpelDnsResolver(servers=[('4.2.2.2', 53)])

f = server.DNSServerFactory(clients=[resolver], verbose=verbosity)

p = dns.DNSDatagramProtocol(f)

f.noisy = p.noisy = verbosity

reactor.listenUDP(5333, p)

reactor.listenTCP(5333, f)

reactor.run()