Foundations of Python Network Programming 978-1-4302-3004-5

CHAPTER 7 ■ SERVER ARCHITECTURE
several child processes (and it is rumored to also have an undocumented ThreadPool), that mechanism
seems focused on distributing work from the master thread rather than on accepting different client
connections from a common listening socket. So my last example in this chapter will be built atop the
modest SocketServer module in the Python Standard Library.
The SocketServer module was written a decade ago, which is probably obvious in the way it uses
multiclassing and mix-ins—today, we would be more likely to use dependency injection and pass in the
threading or forking engine as an argument during instantiation. But the arrangement works well
enough; in Listing 7–10, you can see how small our multi-threaded server becomes when it takes
advantage of this framework. (There is also a ForkingMixIn that you can use if you want it to spawn
several processes—at least on a POSIX system.)
Listing 7–10. Using the Standard Library Socket Server
#!/usr/bin/env python
# Foundations of Python Network Programming - Chapter 7 - server_SocketServer.py
# Answering Launcelot requests with a SocketServer.
from SocketServer import ThreadingMixIn, TCPServer, BaseRequestHandler
import launcelot, server_simple, socket
class MyHandler(BaseRequestHandler):
» def handle(self):
» » server_simple.handle_client(self.request)
class MyServer(ThreadingMixIn, TCPServer):
» allow_reuse_address = 1
» # address_family = socket.AF_INET6 # if you need IPv6
server = MyServer(('', launcelot.PORT), MyHandler)
server.serve_forever()
Note that this framework takes the opposite tack to the server that we built by hand in the previous
section. Whereas our earlier example created the workers up front so that they were all sharing the same
listening socket, the SocketServer does all of its listening in the main thread and creates one worker each
time accept() returns a new client socket. This means that each request will run a bit more slowly, since
the client has to wait for the process or thread to be created before it can receive its first answer; and this
is evident in Figure 7–5, where the volume of requests answered runs a bit lower than it did in Figure 7–4.
A disadvantage of the SocketServer classes, so far as I can see, is that there is nothing to stop a
sudden flood of client connections from convincing the server to spin up an equal number of threads or
processes—and if that number is large, then your computer might well slow to a crawl or run out of
resources rather than respond constructively to the demand. Another advantage to the design of
Listing 7–9, then, is that it chooses ahead of time how many simultaneous requests can usefully be
underway, and leaves additional clients waiting for an accept() on their connections before they can
start contributing to the load on the server.
121