Question

I have been asked to write a class that connects to a server, asynchronously sends the server various commands, and then provides the returned data to the client. I’ve been asked to do this in Python, which is a new language to me. I started digging around and found the Twisted framework which offers some very nice abstractions (Protocol, ProtocolFactory, Reactor) that do a lot of the things that I would have to do if I would roll my own socket-based app. It seems like the right choice given the problem that I have to solve.

I’ve looked through numerous examples on the web (mostly Krondo), but I still haven’t seen a good example of creating a client that will send multiple commands across the wire and I maintain the connection I create. The server (of which I have no control over), in this case, doesn’t disconnect after it sends the response. So, what’s the proper way to design the client so that I can tickle the server in various ways?

Right now I do this:

class TestProtocol(Protocol)
    def connectionMade(self):
         self.transport.write(self.factory.message)

class TestProtocolFactory(Factory):
    message = ''
    def setMessage(self, msg):
        self.message = msg

def main():
    f = TestProtocolFactory()
    f.setMessage("my message")
    reactor.connectTCP(...)
    reactor.run()

What I really want to do is call self.transport.write(...) via the reactor (really, call TestProtocolFactory::setMessage() on-demand from another thread of execution), not just when the connection is made.

Answer 1

Depends. Here are some possibilities:

I’m assuming

Approach 1. You have a list of commands to send the server, and for some reason can’t do them all at once. In that case send a new one as the previous answer returns:

class proto(parentProtocol):
    def stringReceived(self, data):
        self.handle_server_response(data)
        next_command = self.command_queue.pop()
        # do stuff

Approach 2. What you send to the server is based on what the server sends you:

class proto(parentProtocol):
    def stringReceived(self, data):
        if data == "this":
            self.sendString("that")
        elif data == "foo":
            self.sendString("bar")
        # and so on

Approach 3. You don’t care what the server sends to, you just want to periodically send some commands:

class proto(parentProtocol):
    def callback(self):
        next_command = self.command_queue.pop()
        # do stuff
    def connectionMade(self):
        from twisted.internet import task
        self.task_id = task.LoopingCall(self.callback)
        self.task_id.start(1.0)

Approach 4: Your edit now mentions triggering from another thread. Feel free to check the twisted documentation to find out if proto.sendString is threadsafe. You may be able to call it directly, but I don’t know. Approach 3 is threadsafe though. Just fill the queue (which is threadsafe) from another thread.

Basically you can store any amount of state in your protocol; it will stay around until you are done. The you either send commands to the server as a response to it’s messages to you, or you set up some scheduling to do your stuff. Or both.