Refactoring pour un tordu tcp client à partir de l'existant blocage de code

Question

J'ai un programme en python qui utilise actuellement un client tcp/ip module que j'ai écrit pour recevoir des données à partir d'un serveur de streaming.Le serveur affiche les lignes de données.

Mon client TCP classe est assez primitif et je tiens à refactoriser d'utiliser un tordu ReconnectingClientFactory.

Le principal programme récupère les données d'un readLines fonction dans mon Client TCP que les "rendements" les lignes qu'ils sont reçus.

Le client TCP méthode est accessible par:

for msg_buffer in self.myTcpClient.readLines():
    do some stuff with the data in msg_buffer

Dans mon Client TCP la méthode readLines en essence ressemble:

while True:
    newLine = self.sock.recv(self.buffer_size)
    yield newLine

Quand j'mettre en œuvre la torsion du client et je souhaite que d'une certaine façon pour qu'il se comporte comme un itérateur et des données de rendement.Je suppose que je ferais quelque chose dans le protocole dataReceived méthode.

Je suis perdu à essayer de comprendre comment cela fonctionne.Il me semble que tordu différés sont conçus pour ce genre d'utilisation, mais je ne peux pas comprendre comment utiliser un différé pour mon usage (si mon hypothèse sur différés est correct).

Dans un monde parfait, le tordu client pour obtenir les lignes comme tant reçu un appel similaire à la méthode actuelle pour faire le travail.c'est à dire

class GetData(protocol):
    def dataReceived(self, data):
        yield data

Mais je pense que c'est une simplification excessive.

En résumé, ce que j'essaie de faire est de mettre en œuvre une entorse à la reconnexion TCP client qui se comporte quelque chose comme ma méthode readLines et peut être consulté à plus ou moins comme:

for msg_buffer in self.twistedTcpClient.readLines():

Tous les pointeurs sera très appréciée

Mise à JOUR:Je viens de tombé sur "Crochet" pour torsadée.Au premier coup d'œil Crochet semble avoir été conçu pour exactement le genre de modèle que j'ai besoin...Je vais rendre compte après quelques tests

Answer 1

Le Tordu façon de le faire serait d'écrire un Protocole.Au lieu de faire:

for line in self.twistedTcpClient.readLines():
    process_line(line) ...

Vous devez écrire votre Protocole (peut-être par un sous-classement twisted.protocols.basic.LineReceiver):

class MyProtocol(LineReceiver):
    ...
    def lineReceived(self, line):
        process_line(line) ...

Vous souhaitez restructurer le code à utiliser le lineReceived rappel plutôt que d'avoir une itération de la boucle.

Ce que vous avez écrit:

for line in self.twistedTcpClient.readLines():
    process_line(line) ...

est problématique, car Torsadée est asynchrone.Il n'existe aucun moyen pour les Tordus à faire autre chose en attendant twistedTcpClient.readLines() la méthode.

Je suggère la rédaction d'un protocole, mais si vraiment vous insistez pour avoir cet itérateur motif, alors vous pourriez être en mesure de le faire:

@inlineCallbacks
def my_func():
    while True:
        try:
            line = yield self.twistedTcpClient.getNextLine()
        except StopIteration:
            break

        process_line(line) ...

Maintenant, la chose la plus délicate est de faire twistedTcpClient de retour Deferreds pour chaque appel à getNextLine().Peut-être quelque chose comme ceci:

class MyProtocol(LineReceiver):
    ...
    def getNextLine(self):
        self.defer_given_out = Deferred()

    def lineReceived(self, line):
        self.defer_given_out.callback(line)

    def connectionLost(self):
        self.defer_given_out.errback(StopIteration())

(ceci est juste un exemple qui illustre bien l'idée, vous auriez à le prolonger pour manipuler les détails.)