定期遞延扭曲

Question

我的問題看起來像這樣：我有一個Twisted Server，它使用callLater通過TCP每2秒發送一次值。 而且我有一個扭曲的客戶，它可以接收值，並且應該延遲處理接收值。

我的服務器看起來像這樣：

from twisted.internet.protocol import ServerFactory
from twisted.protocols.basic import NetstringReceiver
from random import randint

class ServerProtocol(NetstringReceiver):
    def __init__(self, factory):
        self.factory = factory
        self.sendObject = None

    def connectionMade(self):        
        self.sendValue()

    def connectionLost(self, reason):
        sendObject, self.sendObject = self.sendObject, None
        sendObject.cancel()

    def sendValue(self):
        data = randint(2,20)
        self.sendString(str(data))
        print('send: {0}'.format(data))

        from twisted.internet import reactor
        self.sendObject = reactor.callLater(2, self.sendValue)

class MyServerFactory(ServerFactory):

    def __init__(self):
        self.protsa = []

    def buildProtocol(self, addr):
        return ServerProtocol(self)

    def setCallback(self, callback):
        self.callback = callback    

def serverMain():

    factory = MyServerFactory()
#    factory.setCallback(generateVal)

    from twisted.internet import reactor

    port = reactor.listenTCP(2345, factory, interface='127.0.0.1')     
    print 'Serving on %s.' % (port.getHost())

    reactor.run()


if __name__ == '__main__':
    serverMain()

我的客戶看起來像這樣：

from twisted.internet.protocol import ClientFactory
from twisted.protocols.basic import NetstringReceiver
from twisted.internet import defer


class ClientProtocol(NetstringReceiver):

    def stringReceived(self, string):
        print("recieved")
        self.factory.printValue(string)

    def connectionMade(self):
        print("Made Connection")

    def connetionLost(self):
        print("Connection Lost")

class MyClientFactory(ClientFactory):

    protocol = ClientProtocol

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

    def clientConnectionFailed(self, connector, reason):
        if self.deferred is not None:
            d, self.deferred = self.deferred, None
            d.errback(reason)

    def printValue(self, value):
        if self.deferred is not None:
            d, self.deferred = self.deferred, None
            d.callback(value)


def OutputValue(host, port):
    d = defer.Deferred()
    from twisted.internet import reactor
    factory = MyClientFactory(d)
    reactor.connectTCP(host, port, factory)
    return d

def clientMain():

    def writeError(err):
        print("Deferred Error!\n")
        print("Error: {0}".format(err.__str__))

    def writeValue(value):
        print("Value revieved: {0}".format(value))

    from twisted.internet import reactor

    d = OutputValue('127.0.0.1', 2345)
    d.addCallbacks(writeValue, writeError)

    reactor.run()

if __name__ == '__main__':
    clientMain()

輸出：

Made Connection
recieved
Value revieved: 11
recieved
recieved
recieved

第一次一切正常。 連接后，服務器發送一個客戶端接收的值。 客戶端按要求延遲處理。 第二個值不由延遲處理。 我也希望這樣做，因為延期只開了一次。 現在，我希望可以按遞延方式處理每個收到的值，因此我也可以執行錯誤處理。

我看了一下：

扭曲：推遲發射多次

重用Twisted中的延遲對象

但我無法解決我的問題。 這不是那么尋常。 還是我每次都必須斷開連接並連接？

Answer 1

Deferred是一個對象，代表您提出的特定請求的結果。 但是，由於一個請求只能有一個關聯的響應，就像一個函數只能返回一次一樣，一個Deferred只能被觸發一次。

您已經有一個函數printValue該printValue在接收到值並應打印時運行。 為什么不立即打印該函數中的值，而不是尋找呼叫者設置的Deferred？