bonne façon d'écrire une fonction de client léger à importer Twisted Python

Question

je le fonctionnement du serveur suivant:

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() 

J'ai plusieurs fichiers importer une fonction spéciale appelée « getHash » à partir d'un fichier particulier. Notez que les arguments de getHash ne seront qu'un dictionnaire de textes (chaînes de caractères). Comment puis-je écrire une fonction client (getHash) qui peut être simplement:

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

Notez que TOUT CE QUE JE VEUX FAIRE est: 1) de jeter un dict en JSON, 2) Dump JSON dans le particulier socket, 3) attendez que cela revienne et déballez le json

Answer 1

Vous voulez getHash pour retourner un Deferred, pas une valeur synchrone.

Pour ce faire, créez un Deferred et associez-le à la connexion qui effectue une requête particulière.

Ce qui suit est non testé et ne fonctionnera probablement pas, mais il devrait vous donner une idée approximative:

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 

Maintenant, pour utilisation cette fonction, vous aurez déjà besoin de se familiariser avec Différé, et vous aurez besoin d'écrire une fonction de rappel à exécuter lorsque le résultat arrive finalement. Mais une explication de ceux-ci appartient à une question séparée;).

Answer 2

J'ai réussi à résoudre mon propre problème.

Utiliser des douilles (prises Unix en particulier) ça accélère mon application 4x et ce n'est pas difficile à utiliser du tout.

maintenant ma solution est simplejson + prise