Python Socket Server

⚠️ This article was originally published in 2005 at dubi.org/python-socket-server-for-flash. The content is extremely outdated and is preserved here for nostalgic purposes only.

Flash has the ability to open up sockets with a server and send/receive XML (well, arbitrary strings as well). Mike and I decided to hack together a chat app super fast just to see what Flash could do. He’s a Flash nerd so he did that part and I learned Python to write the server. Turns out Python is pretty neat and I thought I’d provide an example of how to write a Flash XML Socket Server in Python.

Note: this code may suck, as I’ve never written Python before

First we import the appropriate libraries:

1
from optparse import OptionParser
2
from elementtree import ElementTree
3
import thread, socket, sys

Then, if we’re not importing the file, we make an entry point into the application (this would go after the class declaration):

1
if __name__ == '__main__':
2
    parser = OptionParser()
3
    parser.add_option("-p", "--port",
4
                        action="store", dest="PORT", type="int", default=2900,
5
                        help="PORT to bind to", metavar="PORT")
6
    parser.add_option("--host",
7
                        action="store", type="string", dest="HOST", default='',
8
                        help="HOST to bind to", metavar="HOST")
9

10
    (options, args) = parser.parse_args()
11

12
    new_server = flashServer(options.HOST, options.PORT)

This reads an optional port and host from the command line and overrides the defaults. It also starts the server.

Then we define the server class:

1
class flashServer:
2
    mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
3
    open_channels = {}
4
    BUFSIZE = 1024

BUFSIZE is how much we read at one time. open_channels is a dictionary of open socket connections. The key is the (ip, port) tuple and the value is the socket.

1
    def __init__(self, host='', port=2900):
2
        print 'Starting server...'
3
        try:
4
            self.mySocket.bind((host, port))
5
            self.mySocket.listen(5)
6
            print 'Server started successfully'
7
        except:
8
            print 'Server failed to start'
9
            return
10

11
        while True:
12
            try:
13
                socket = self.mySocket.accept()
14

15
            except:
16
                print 'Error: failed to accept connection'
17
                continue
18

19
            channel, details = socket
20
            print 'We have opened a connection with ', details
21
            self.open_channels[details] = channel
22
            thread.start_new_thread(self.connect, (channel, details))

This ctor should be straightforward. We attempt to bind to the host/port. After that, we enter an infinite loop accepting connections and threading off to handle each new connection. The function that is fired in the new thread is flashServer.connect and we pass it the (socket, (ip, port)) nested tuple as an argument.

flashServer.connect accumulates data BUFSIZE bytes at a time. When it encounters \0, it sends the data to flashServer.parse_cmd.

flashServer.parse_cmd is where the magic happens. It parses the XML and reads in the root tag. The root tag is the name of the function that the XML Document gets sent to for more processing:

1
        func_name = 'xml_'+xmldoc.tag
2
        if hasattr(self, func_name):
3
            getattr(self, func_name)(xmldoc, details)
4
        else:
5
            self.open_channels[details].send('<error>Invalid Command</error>\0')

So, had the client sent <test>1.2.3..</test>\0, the function xml_test would be called. Invalid tags (i.e. ones with no corresponding function) generate an error response. As you need more functions, all you have to do is define them. If you want to accept <login><user>bob</user><password>god</password></login>\0, all you have to do is define xml_login and put the appropriate code in there.

It should be fairly easy to extend this into a simple server that actually does something.

Happy hacking