Twisted推遲定期調用

Question

我的問題是這樣的： 我有一個扭曲的服務器，它每隔2秒通過TCP發送一個值，並帶有callLater。而且我有一個扭曲的客戶，它接受了價值，並且應該用延期來處理收受價值。

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

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: deferred that fires repeatedly

Re-using deferred objects in Twisted

，但我不能讓我的問題的解決方案的保持。這不可能如此不尋常。 或者我每次都必須斷開連接嗎？

Answer 1

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

您已擁有一項功能 - printValue - 在接收到值並應打印時運行。爲什麼不直接在該函數中打印值，而不是去尋找你的調用者設置的延遲？