client_tornado.py

import socket

import tornado
import tornado.ioloop
import tornado.iostream

import client
import functools

class LockdClientTornado( client.LockdClient ):
    io_loop = None
    connect_callback = None

    def __init__( self, host = '', port = 0, timeout = 0.1, callback = None, io_loop = None ):
        self.io_loop = io_loop

        super( LockdClientTornado, self ).__init__( host, port, timeout, callback = callback )

    def connect( self, callback = None ):
        self.socket = socket.socket( socket.AF_INET, socket.SOCK_STREAM, 0 )
        self.name = self._default_name()
        self.stream = tornado.iostream.IOStream( self.socket, io_loop = self.io_loop )
        self.stream.set_nodelay( True )
        self.stream.connect( ( self.host, self.port ), callback = callback )

    def close( self ):
        self.stream.close()
        self.name = None

    # todo: iam() should set self.name before calling callback

    def _send_recv( self, command, name = None, type = 'int', callback = None ):
        def proceed( proceed = True ):
            if not proceed:
                if callback:
                    callback( proceed )
                return
            self._recv( type, callback )

        self._send( command, name, proceed )

    def _send( self, command, name = None, callback = None ):
        if name is None:
            command += "\r\n"
        else:
            command = "%s %s\r\n" % ( command, name )

        try:
            self.stream.write( command, callback )
        except Exception, e:
            callback( False )

    def _recv( self, type = 'int', callback = None ):
        def parse( reply ):
            callback( self._parse( reply ) )

        self.stream.read_until( "\n", parse )

class LockdClient( object ):
    client = None
    queue = []

    def __init__( self, host = '', port = 0, timeout = 0.1, callback = None, io_loop = None ):
        self.client = LockdClientTornado( host, port, timeout, callback = callback, io_loop = io_loop )
        self.queue = []

    def run_next( self ):
        if self.queue:
            self.queue[0]()

    def request_done(self, callback, result):
        if callback:
            self.client.io_loop.add_callback( functools.partial( callback, result ) )
        del self.queue[0]
        self.client.io_loop.add_callback( self.run_next )

    def __getattr__( self, name ):
        if name in ( 'whoami', 'close' ):
            return getattr( self.client, name )

        def f( *a, **kw ):
            _callback = kw.get('callback')
            kw['callback'] = functools.partial( self.request_done, _callback )

            def request():
                print "running request"
                getattr( self.client, name )( *a, **kw )

            print "appended"
            self.queue.append( request )
            if len( self.queue ) == 1:
                self.client.io_loop.add_callback( self.run_next )
        return f