BaseServer 源码:

class BaseServer:    """Base class for server classes.    Methods for the caller:    - __init__(server_address, RequestHandlerClass)    - serve_forever(poll_interval=0.5)    - shutdown()    - handle_request()  # if you do not use serve_forever()    - fileno() -> int   # for select()    Methods that may be overridden:    - server_bind()    - server_activate()    - get_request() -> request, client_address    - handle_timeout()    - verify_request(request, client_address)    - server_close()    - process_request(request, client_address)    - shutdown_request(request)    - close_request(request)    - handle_error()    Methods for derived classes:    - finish_request(request, client_address)    Class variables that may be overridden by derived classes or    instances:    - timeout    - address_family    - socket_type    - allow_reuse_address    Instance variables:    - RequestHandlerClass    - socket    """    timeout = None    def __init__(self, server_address, RequestHandlerClass):        """Constructor.  May be extended, do not override."""        self.server_address = server_address        self.RequestHandlerClass = RequestHandlerClass        self.__is_shut_down = threading.Event()        self.__shutdown_request = False    def server_activate(self):        """Called by constructor to activate the server.        May be overridden.        """        pass    def serve_forever(self, poll_interval=0.5):        """Handle one request at a time until shutdown.        Polls for shutdown every poll_interval seconds. Ignores        self.timeout. If you need to do periodic tasks, do them in        another thread.        """        self.__is_shut_down.clear()        try:            while not self.__shutdown_request:                # XXX: Consider using another file descriptor or                # connecting to the socket to wake this up instead of                # polling. Polling reduces our responsiveness to a                # shutdown request and wastes cpu at all other times.                r, w, e = _eintr_retry(select.select, [self], [], [],                                       poll_interval)                if self in r:                    self._handle_request_noblock()        finally:            self.__shutdown_request = False            self.__is_shut_down.set()    def shutdown(self):        """Stops the serve_forever loop.        Blocks until the loop has finished. This must be called while        serve_forever() is running in another thread, or it will        deadlock.        """        self.__shutdown_request = True        self.__is_shut_down.wait()    # The distinction between handling, getting, processing and    # finishing a request is fairly arbitrary.  Remember:    #    # - handle_request() is the top-level call.  It calls    #   select, get_request(), verify_request() and process_request()    # - get_request() is different for stream or datagram sockets    # - process_request() is the place that may fork a new process    #   or create a new thread to finish the request    # - finish_request() instantiates the request handler class;    #   this constructor will handle the request all by itself    def handle_request(self):        """Handle one request, possibly blocking.        Respects self.timeout.        """        # Support people who used socket.settimeout() to escape        # handle_request before self.timeout was available.        timeout = self.socket.gettimeout()        if timeout is None:            timeout = self.timeout        elif self.timeout is not None:            timeout = min(timeout, self.timeout)        fd_sets = _eintr_retry(select.select, [self], [], [], timeout)        if not fd_sets[0]:            self.handle_timeout()            return        self._handle_request_noblock()    def _handle_request_noblock(self):        """Handle one request, without blocking.        I assume that select.select has returned that the socket is        readable before this function was called, so there should be        no risk of blocking in get_request().        """        try:            request, client_address = self.get_request()        except socket.error:            return        if self.verify_request(request, client_address):            try:                self.process_request(request, client_address)            except:                self.handle_error(request, client_address)                self.shutdown_request(request)    def handle_timeout(self):        """Called if no new request arrives within self.timeout.        Overridden by ForkingMixIn.        """        pass    def verify_request(self, request, client_address):        """Verify the request.  May be overridden.        Return True if we should proceed with this request.        """        return True    def process_request(self, request, client_address):        """Call finish_request.        Overridden by ForkingMixIn and ThreadingMixIn.        """        self.finish_request(request, client_address)        self.shutdown_request(request)    def server_close(self):        """Called to clean-up the server.        May be overridden.        """        pass    def finish_request(self, request, client_address):        """Finish one request by instantiating RequestHandlerClass."""        self.RequestHandlerClass(request, client_address, self)    def shutdown_request(self, request):        """Called to shutdown and close an individual request."""        self.close_request(request)    def close_request(self, request):        """Called to clean up an individual request."""        pass    def handle_error(self, request, client_address):        """Handle an error gracefully.  May be overridden.        The default is to print a traceback and continue.        """        print '-'*40        print 'Exception happened during processing of request from',        print client_address        import traceback        traceback.print_exc() # XXX But this goes to stderr!        print '-'*40

TCPServer源码：

class TCPServer(BaseServer):    """Base class for various socket-based server classes.    Defaults to synchronous IP stream (i.e., TCP).    Methods for the caller:    - __init__(server_address, RequestHandlerClass, bind_and_activate=True)    - serve_forever(poll_interval=0.5)    - shutdown()    - handle_request()  # if you don't use serve_forever()    - fileno() -> int   # for select()    Methods that may be overridden:    - server_bind()    - server_activate()    - get_request() -> request, client_address    - handle_timeout()    - verify_request(request, client_address)    - process_request(request, client_address)    - shutdown_request(request)    - close_request(request)    - handle_error()    Methods for derived classes:    - finish_request(request, client_address)    Class variables that may be overridden by derived classes or    instances:    - timeout    - address_family    - socket_type    - request_queue_size (only for stream sockets)    - allow_reuse_address    Instance variables:    - server_address    - RequestHandlerClass    - socket    """    address_family = socket.AF_INET    socket_type = socket.SOCK_STREAM    request_queue_size = 5    allow_reuse_address = False    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):        """Constructor.  May be extended, do not override."""        BaseServer.__init__(self, server_address, RequestHandlerClass)        self.socket = socket.socket(self.address_family,                                    self.socket_type)        if bind_and_activate:            try:                self.server_bind()                self.server_activate()            except:                self.server_close()                raise    def server_bind(self):        """Called by constructor to bind the socket.        May be overridden.        """        if self.allow_reuse_address:            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)        self.socket.bind(self.server_address)        self.server_address = self.socket.getsockname()    def server_activate(self):        """Called by constructor to activate the server.        May be overridden.        """        self.socket.listen(self.request_queue_size)    def server_close(self):        """Called to clean-up the server.        May be overridden.        """        self.socket.close()    def fileno(self):        """Return socket file number.        Interface required by select().        """        return self.socket.fileno()    def get_request(self):        """Get the request and client address from the socket.        May be overridden.        """        return self.socket.accept()    def shutdown_request(self, request):        """Called to shutdown and close an individual request."""        try:            #explicitly shutdown.  socket.close() merely releases            #the socket and waits for GC to perform the actual close.            request.shutdown(socket.SHUT_WR)        except socket.error:            pass #some platforms may raise ENOTCONN here        self.close_request(request)    def close_request(self, request):        """Called to clean up an individual request."""        request.close()

class ThreadingMixIn:    """Mix-in class to handle each request in a new thread."""    # Decides how threads will act upon termination of the    # main process    daemon_threads = False    def process_request_thread(self, request, client_address):        """Same as in BaseServer but as a thread.        In addition, exception handling is done here.        """        try:            self.finish_request(request, client_address)            self.shutdown_request(request)        except:            self.handle_error(request, client_address)            self.shutdown_request(request)    def process_request(self, request, client_address):        """Start a new thread to process the request."""        t = threading.Thread(target = self.process_request_thread,                             args = (request, client_address))        t.daemon = self.daemon_threads        t.start()

class ThreadingTCPServer(ThreadingMixIn, TCPServer):

   pass

BaseRequestHandler源码:

class BaseRequestHandler:    """Base class for request handler classes.    This class is instantiated for each request to be handled.  The    constructor sets the instance variables request, client_address    and server, and then calls the handle() method.  To implement a    specific service, all you need to do is to derive a class which    defines a handle() method.    The handle() method can find the request as self.request, the    client address as self.client_address, and the server (in case it    needs access to per-server information) as self.server.  Since a    separate instance is created for each request, the handle() method    can define arbitrary other instance variariables.    """    def __init__(self, request, client_address, server):        self.request = request        self.client_address = client_address        self.server = server        self.setup()        try:            self.handle()        finally:            self.finish()    def setup(self):        pass    def handle(self):        pass    def finish(self):        pass