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

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