Good way to write a lightweight client function to be imported Twisted Python

Question

Dear everyone, I have the following server running:

class ThasherProtocol(basic.LineReceiver):
    def lineReceived(self, line):
        dic = simplejson.loads( line)
        ret = self.factory.d[ dic['method'] ]( dic['args'] )
        self.transport.write( simplejson.dumps( ret) )
        self.transport.loseConnection()



class ThasherFactory(ServerFactory):
    protocol = ThasherProtocol 

    def __init__(self):
        self.thasher = Thasher()
        self.d= {   
            'getHash': self.thasher.getHash,
            'sellHash' : self.thasher.sellHash
            }


reactor.listenUNIX( c.LOCATION_THASHER, ThasherFactory() )
reactor.run()

I have multiple files importing a special function called "getHash" from a particular file. Note that getHash's arguments are only gonna be a dictionary of texts (strings). How do I write a client function (getHash) that can be simply:

from particular file import getHash
i = getHash( { 'type':'url', 'url':'http://www.stackoverflow.com' } )

Note that ALL I WANT TO DO is: 1) dump a dict into json, 2) dump that json into the particular socket, 3) wait for that to come back and unpack the json

Answer 1

You want getHash to return a Deferred, not a synchronous value.

The way to do this is to create a Deferred and associate it with the connection that performs a particular request.

The following is untested and probably won't work, but it should give you a rough idea:

import simplejson
from twisted.python.protocol import ClientFactory
from twisted.internet.defer import Deferred
from twisted.internet import reactor
from twisted.protocols.basic import LineReceiver

class BufferingJSONRequest(LineReceiver):
    buf = ''

    def connectionMade(self):
        self.sendLine(simplejson.dumps(self.factory.params))

    def dataReceived(self, data):
        self.buf += data

    def connectionLost(self, reason):
        deferred = self.factory.deferred
        try:
            result = simplejson.load(self.buf)
        except:
            deferred.errback()
        else:
            deferred.callback(result)

class BufferingRequestFactory(ClientFactory):
    protocol = BufferingJSONRequest

    def __init__(self, params, deferred):
        self.params = params
        self.deferred = deferred

    def clientConnectionFailed(self, connector, reason):
        self.deferred.errback(reason)

def getHash(params):
    result = Deferred()
    reactor.connectUNIX(LOCATION_THASHER,
                        BufferingRequestFactory(params, result))
    return result

Now, in order to use this function, you will already need to be familiar with Deferreds, and you will need to write a callback function to run when the result eventually arrives. But an explanation of those belongs on a separate question ;).

Answer 2

I managed to solve my own problem.

Use sockets (Unix sockets in particular) it speed up my app 4x and it's not difficult to use at all.

so now my solution is simplejson + socket