在Twisted中从一台服务器向另一台服务器发送消息

Question

I'm a complete Twisted AND Python noob, so my apologies if any of my terminology is wrong or anything I've done is silly. Nonetheless....

I've implemented my servers in the following way:

def makeServer(application, port):
    factory = protocol.ServerFactory()
    factory.protocol = MyChat
    factory.clients = []
    tempServer = internet.TCPServer(port, factory)
    tempServer.setServiceParent(application)
    return tempServer

application = service.Application("chatserver")
server1 = makeServer(application, port=1025)
server2 = makeServer(application, port=1026)
server3 = makeServer(application, port=1027)

Note that MyChat is an event handling class that has a "receiveMessage" action:

def lineReceived(self, line):
    print "received", repr(line)
    for c in self.factory.clients:
       c.transport.write(message + '\n')

I want server1 to be able to pass messages to server2. Rather, I want server1 to be treated as a client of server2. If server1 receives the message "hi" then I want it to send that same exact message to server2. The only thing server1 needs to be able to do is to send the message it received from its client to server2.

How can I accomplish this?

NOTE: You can totally change the way I'm implementing my server if it helps.

Answer 1

Different parts of your application can interact with each other using method calls.

Send a message to server2 really just means Call a method on one of the objects related to server2 .

For example, in MyChat , you might have:

def lineReceived(self, line):
   print "received", repr(line)
   for c in self.factory.clients:
       c.transport.write(message + '\n')
   for server in self.factory.otherServers:
       server.otherServerMessage(self, line)

This supposes a couple things:

• You add a new otherServers attribute to your factory. Its contents are objects related to the other listening servers you have set up. These might be factory objects or protocol objects. It depends on what's most convenient based on what you intend to do with the message.
• You give those related objects a new method, otherServerMessage , to handle messages delivered this way. If you were to deliver the messages directly to MyChat.lineReceived (which you easily could, if you wanted) then I would expect you to end up with infinite recursion; having a different method lets you differentiate between messages received from a client and messages received from another server.

Answer 2

You need just declare clients inside your server, like this:

factory = SomeClientFactory('ws://127.0.0.1')            
connectWS(factory)

and in your Client Class:

class SomeClient(WebSocketClientProtocol):

    def __init__(self):
       pass

    def sendCommand(self):    

        self.sendMessage('A message to another server')

    def onOpen(self):
        self.sendCommand()

    def onClose(self, wasClean, code, reason):
        print(reason)

    def onMessage(self, payload, isBinary):
        print('A answer from another server')

class SomeClientFactory(WebSocketClientFactory):

    def __init__(self, url): 
        WebSocketClientFactory.__init__(self,url)

        self.proto = DeltaClient()        
        self.proto.factory = self

    def buildProtocol(self, addr):        
        return self.proto  

Tip: use a "Controller" class to manage that instances of clients inside your servers.

Answer 3

You will probably need to implement a separate client. It is possible that an object can be both a client and a server, but I doubt it will be worth it and you are likely to run into trouble.

I suggest that the server instantiates a client object, which you connect to the 'next' server. The client can for example be an instance variable on the server.

Example:

class MyChat(LineReceiver):
    def connectionMade(self):
        print "Proxy: connected"
        factory = protocol.ClientFactory()
        class Proxy(protocol.Protocol):
            def relayMessage(self, msg):
                self.transport.write(msg)
        factory.protocol = Proxy
        point = TCP4ClientEndpoint(reactor, "localhost", 1025)
        conn = point.connect(factory)
        conn.addCallback(self.hasConnection)
    def hasConnection(self, client):
        print "Proxy: Connected to relay", client
        self.client = client
    def lineReceived(self, line):
        print "Proxy: received", repr(line)
        self.client.transport.write(line+"\n")

class MyEcho(LineReceiver):
    def lineReceived(self, line):
        print "Echo:  received", repr(line)

factory = protocol.ServerFactory()
factory.protocol = MyChat
reactor.listenTCP(1024, factory)

factory = protocol.ServerFactory()
factory.protocol = MyEcho
reactor.listenTCP(1025, factory)