Twisted Inter-protocol Communication

README.md

Inter-protocol Communication

Run it

Open three terminals, then (in order):

• python server_b.py
• python server_a.py
• python client.py

Start server b. Then start server a which connects to server b. Finally, start client which talks to server a.

This is Convoluted

I agree. There's got to be a simpler way.

client.py

from definitions import EchoClientFactory

from twisted.internet.endpoints import TCP4ClientEndpoint, connectProtocol
from twisted.internet import reactor


def main():

    client_factory = EchoClientFactory()
    reactor.connectTCP('localhost', 1234, client_factory)

    reactor.run()


if __name__ == "__main__":

    main()

definitions.py

from twisted.internet.protocol import Protocol, Factory


class ServerEcho(Protocol):

    def __init__(self, factory):

        self.factory = factory

    def dataReceived(self, data):

        print('Gonna do an echo of {}'.format(data))
        self.transport.write(data)

        print('Gonna pass along to my registry, too: {}'.format(self.factory.foreign_factory))
        if self.factory.foreign_factory:
            for instance in self.factory.foreign_factory.instances:
                instance.make_call()


class ServerEchoFactory(Factory):

    protocol = ServerEcho

    def __init__(self, foreign_factory=None):

        print('Was passed this: {}'.format(foreign_factory))
        self.foreign_factory = foreign_factory

    def buildProtocol(self, addr):

        instance = self.protocol(self)

        return instance


class EchoClient(Protocol):

    def __init__(self, factory):

        self.factory = factory

    def connectionMade(self):

        print("echo client should be registering...")
        self.factory.register(self)
        print(self.factory.instances)
        msg = "Hello server, I am a client!\r\n"
        self.send(msg)

    def send(self, msg):

        print("Sending {}".format(msg))
        self.transport.write(msg)

    def connectionLost(self, reason):

        self.factory.unregister(self)

    def make_call(self):

        msg = 'I am an echo client instance, and I just made a call.\r\n'
        self.send(msg)


class EchoClientFactory(Factory):

    protocol = EchoClient

    def __init__(self):

        self.instances = set()

    def buildProtocol(self, addr):

        instance = self.protocol(self)

        return instance

    def startedConnecting(self, connectorInstance):

        pass

    def clientConnectionLost(self, connection, reason):

        pass

    def register(self, instance):

        self.instances.add(instance)

        return self

    def unregister(self, instance):

        try:
            self.instances.remove(instance)
        except:
            pass

        return self

server_a.py

from definitions import ServerEchoFactory, EchoClientFactory

from twisted.internet.endpoints import TCP4ServerEndpoint
from twisted.internet.endpoints import TCP4ClientEndpoint, connectProtocol
from twisted.internet import reactor


def main():

    # client
    client_factory = EchoClientFactory()
    reactor.connectTCP('localhost', 1235, client_factory)

    # server
    endpoint = TCP4ServerEndpoint(reactor, 1234)
    factory = ServerEchoFactory(client_factory)
    endpoint.listen(factory)

    reactor.run()


if __name__ == "__main__":

    main()

server_b.py

from definitions import ServerEchoFactory

from twisted.internet.endpoints import TCP4ServerEndpoint
from twisted.internet import reactor


def main():

    endpoint = TCP4ServerEndpoint(reactor, 1235)
    factory = ServerEchoFactory()
    endpoint.listen(factory)

    reactor.run()


if __name__ == "__main__":

    main()