网络编程基础详解编程语言

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

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() 
 
TCPServer

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() 
 
ThreadingMixIn

class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

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 
 
SocketServer.BaseRequestHandler