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

CHAPTER 7 ■ SERVER ARCHITECTURE
single client and then sends back the information it needs—and run several copies of it at once so that
we can serve several clients at once, without making them wait on each other.
The event-driven approaches in Listings 7–7 and 7–8 place upon our own program the burden of
figuring out which client is ready next, and how to interleave requests and responses depending on the
order in which they arrive. But when using threads and processes, you get to transfer this burden to the
operating system itself. Each thread controls one client socket; it can use blocking recv() and send()
calls to wait until data can be received and transmitted; and the operating system then decides which
workers to leave idle and which to wake up.
Using multiple threads or processes is very common, especially in high-capacity web and database
servers. The Apache web server even comes with both: its prefork module offers a pool of processes,
while the worker module runs multiple threads instead.
Listing 7–9 shows a simple server that creates multiple workers. Note how pleasantly symmetrical
the Standard Library authors have made the interface between threads and processes, thanks especially
to Jesse Noller and his recent work on the multiprocessing module. The main program logic does not
even know which solution is being used; the two classes have a similar enough interface that either
Thread or Process can here be used interchangeably.
Listing 7–9. Multi-threaded or Multi-process Server
#!/usr/bin/env python
# Foundations of Python Network Programming - Chapter 7 - server_multi.py
# Using multiple threads or processes to serve several clients in parallel.
import sys, time, launcelot
from multiprocessing import Process
from server_simple import server_loop
from threading import Thread
WORKER_CLASSES = {'thread': Thread, 'process': Process}
WORKER_MAX = 10
def start_worker(Worker, listen_sock):
» worker = Worker(target=server_loop, args=(listen_sock,))
» worker.daemon = True # exit when the main process does
» worker.start()
» return worker
if __name__ == '__main__':
» if len(sys.argv) != 3 or sys.argv[2] not in WORKER_CLASSES:
» » print >>sys.stderr, 'usage: server_multi.py interface thread|process'
» » sys.exit(2)
» Worker = WORKER_CLASSES[sys.argv.pop()] # setup() wants len(argv)==2
» # Every worker will accept() forever on the same listening socket.
» listen_sock = launcelot.setup()
» workers = []
» for i in range(WORKER_MAX):
» » workers.append(start_worker(Worker, listen_sock))
» # Check every two seconds for dead workers, and replace them.
» while True:
» » time.sleep(2)
118