gistfile1.py

import eventlet
from thrift.server.TServer import TServer
from thrift.transport import TSocket;
from thrift.transport.TTransport import TTransportException

class TEventletServer(TServer):
    """Eventlet Thrift Server.  Each client gets its own green thread."""
    running = False
    backdoor = 0
    def __init__(self, *args, **kwargs):
        if kwargs.get('backdoor', None):
            self.backdoor = kwargs.get('backdoor')
            
        super(TServer, self).__init__(args)
        
    def serve(self):
        self.running = True
        if self.backdoor:
            eventlet.spawn(eventlet.backdoor.backdoor_server, 
                eventlet.listen(('localhost', self.backdoor)))
        
        self.serverTransport.listen()
        while self.running:
            client = self.serverTransport.accept()
            eventlet.spawn_n(self._handle, client)
            
    def _handle(self, client):
        """A greenlet for handling a single client."""
        itrans = self.inputTransportFactory.getTransport(client)
        otrans = self.outputTransportFactory.getTransport(client)
        iprot = self.inputProtocolFactory.getProtocol(itrans)
        oprot = self.outputProtocolFactory.getProtocol(otrans)
        try:
            while True:
                self.processor.process(iprot, oprot)
        except TTransportException, e:
            pass
        except Exception, e:
            pass
            
        itrans.close()
        otrans.close()

class TEventletPoolServer(TEventletServer):
    """Eventlet Thrift Server using a GreenPool.  
    Each client queued/handled by the pool."""
    
    pool_size = 10000
    def __init__(self, *args, **kwargs):
        if kwargs.get('pool_size', None):
            self.pool_size = kwargs.get('pool_size')
            
        super(TEventletServer, self).__init__(args, kwargs)
        
    def serve(self):
        self.running = True
        pool = eventlet.GreenPool(self.pool_size)
        self.serverTransport.listen()
        while self.running:
            client = self.serverTransport.accept()
            pool.spawn_n(self._handle, client)