← Back
Editing: socketserver.cpython-33.pyo
� �� f�^ c @ sS d Z d Z d d l Z d d l Z d d l Z d d l Z d d l Z y d d l Z Wn e k rx d d l Z Yn Xd d d d d d d d d d d g Z e e d � r� e j d d d d g � n d d � Z Gd d � d � Z Gd d � d e � Z Gd d � d e � Z Gd d � d � Z Gd d � d � Z Gd d � d e e � Z Gd d � d e e � Z Gd d � d e e � Z Gd d � d e e � Z e e d � rGd d � d e � Z Gd! d � d e � Z Gd" d � d e e � Z Gd# d � d e e � Z n Gd$ d � d � Z Gd% d � d e � Z Gd& d � d e � Z d S(' u� Generic socket server classes. This module tries to capture the various aspects of defining a server: For socket-based servers: - address family: - AF_INET{,6}: IP (Internet Protocol) sockets (default) - AF_UNIX: Unix domain sockets - others, e.g. AF_DECNET are conceivable (see <socket.h> - socket type: - SOCK_STREAM (reliable stream, e.g. TCP) - SOCK_DGRAM (datagrams, e.g. UDP) For request-based servers (including socket-based): - client address verification before further looking at the request (This is actually a hook for any processing that needs to look at the request before anything else, e.g. logging) - how to handle multiple requests: - synchronous (one request is handled at a time) - forking (each request is handled by a new process) - threading (each request is handled by a new thread) The classes in this module favor the server type that is simplest to write: a synchronous TCP/IP server. This is bad class design, but save some typing. (There's also the issue that a deep class hierarchy slows down method lookups.) There are five classes in an inheritance diagram, four of which represent synchronous servers of four types: +------------+ | BaseServer | +------------+ | v +-----------+ +------------------+ | TCPServer |------->| UnixStreamServer | +-----------+ +------------------+ | v +-----------+ +--------------------+ | UDPServer |------->| UnixDatagramServer | +-----------+ +--------------------+ Note that UnixDatagramServer derives from UDPServer, not from UnixStreamServer -- the only difference between an IP and a Unix stream server is the address family, which is simply repeated in both unix server classes. Forking and threading versions of each type of server can be created using the ForkingMixIn and ThreadingMixIn mix-in classes. For instance, a threading UDP server class is created as follows: class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass The Mix-in class must come first, since it overrides a method defined in UDPServer! Setting the various member variables also changes the behavior of the underlying server mechanism. To implement a service, you must derive a class from BaseRequestHandler and redefine its handle() method. You can then run various versions of the service by combining one of the server classes with your request handler class. The request handler class must be different for datagram or stream services. This can be hidden by using the request handler subclasses StreamRequestHandler or DatagramRequestHandler. Of course, you still have to use your head! For instance, it makes no sense to use a forking server if the service contains state in memory that can be modified by requests (since the modifications in the child process would never reach the initial state kept in the parent process and passed to each child). In this case, you can use a threading server, but you will probably have to use locks to avoid two requests that come in nearly simultaneous to apply conflicting changes to the server state. On the other hand, if you are building e.g. an HTTP server, where all data is stored externally (e.g. in the file system), a synchronous class will essentially render the service "deaf" while one request is being handled -- which may be for a very long time if a client is slow to read all the data it has requested. Here a threading or forking server is appropriate. In some cases, it may be appropriate to process part of a request synchronously, but to finish processing in a forked child depending on the request data. This can be implemented by using a synchronous server and doing an explicit fork in the request handler class handle() method. Another approach to handling multiple simultaneous requests in an environment that supports neither threads nor fork (or where these are too expensive or inappropriate for the service) is to maintain an explicit table of partially finished requests and to use select() to decide which request to work on next (or whether to handle a new incoming request). This is particularly important for stream services where each client can potentially be connected for a long time (if threads or subprocesses cannot be used). Future work: - Standard classes for Sun RPC (which uses either UDP or TCP) - Standard mix-in classes to implement various authentication and encryption schemes - Standard framework for select-based multiplexing XXX Open problems: - What to do with out-of-band data? BaseServer: - split generic "request" functionality out into BaseServer class. Copyright (C) 2000 Luke Kenneth Casson Leighton <lkcl@samba.org> example: read entries from a SQL database (requires overriding get_request() to return a table entry from the database). entry is processed by a RequestHandlerClass. u 0.4i Nu TCPServeru UDPServeru ForkingUDPServeru ForkingTCPServeru ThreadingUDPServeru ThreadingTCPServeru BaseRequestHandleru StreamRequestHandleru DatagramRequestHandleru ThreadingMixInu ForkingMixInu AF_UNIXu UnixStreamServeru UnixDatagramServeru ThreadingUnixStreamServeru ThreadingUnixDatagramServerc G sX xQ y | | � SWq t k rP } z | j t j k r> � n WYd d } ~ Xq Xq d S( u* restart a system call interrupted by EINTRN( u OSErroru errnou EINTR( u funcu argsu e( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu _eintr_retry� s u _eintr_retryc B s� | Ee Z d Z d Z d! Z d d � Z d d � Z d d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d! S(" u BaseServeru� 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) - service_actions() - 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 c C s. | | _ | | _ t j � | _ d | _ d S( u/ Constructor. May be extended, do not override.NF( u server_addressu RequestHandlerClassu threadingu Eventu _BaseServer__is_shut_downu Falseu _BaseServer__shutdown_request( u selfu server_addressu RequestHandlerClass( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu __init__� s u BaseServer.__init__c C s d S( uS Called by constructor to activate the server. May be overridden. N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu server_activate� s u BaseServer.server_activateg �?c C s� | j j � z^ xW | j si t t j | g g g | � \ } } } | | k r\ | j � n | j � q WWd d | _ | j j � Xd S( u� 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. NF( u _BaseServer__is_shut_downu clearu _BaseServer__shutdown_requestu _eintr_retryu selectu _handle_request_noblocku service_actionsu Falseu set( u selfu poll_intervalu ru wu e( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu serve_forever� s u BaseServer.serve_foreverc C s d | _ | j j � d S( u� 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. NT( u Trueu _BaseServer__shutdown_requestu _BaseServer__is_shut_downu wait( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu shutdown� s u BaseServer.shutdownc C s d S( u� Called by the serve_forever() loop. May be overridden by a subclass / Mixin to implement any code that needs to be run during the loop. N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu service_actions s u BaseServer.service_actionsc C s� | j j � } | d k r' | j } n$ | j d k rK t | | j � } n t t j | g g g | � } | d s� | j � d S| j � d S( uO Handle one request, possibly blocking. Respects self.timeout. i N( u socketu gettimeoutu Noneu timeoutu minu _eintr_retryu selectu handle_timeoutu _handle_request_noblock( u selfu timeoutu fd_sets( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu handle_request s u BaseServer.handle_requestc C s� y | j � \ } } Wn t j k r1 d SYn X| j | | � r� y | j | | � Wq� | j | | � | j | � Yq� Xn d S( u� 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(). N( u get_requestu socketu erroru verify_requestu process_requestu handle_erroru shutdown_request( u selfu requestu client_address( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu _handle_request_noblock% s u" BaseServer._handle_request_noblockc C s d S( uc Called if no new request arrives within self.timeout. Overridden by ForkingMixIn. N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu handle_timeout7 s u BaseServer.handle_timeoutc C s d S( un Verify the request. May be overridden. Return True if we should proceed with this request. T( u True( u selfu requestu client_address( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu verify_request> s u BaseServer.verify_requestc C s! | j | | � | j | � d S( uV Call finish_request. Overridden by ForkingMixIn and ThreadingMixIn. N( u finish_requestu shutdown_request( u selfu requestu client_address( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu process_requestF s u BaseServer.process_requestc C s d S( uD Called to clean-up the server. May be overridden. N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu server_closeO s u BaseServer.server_closec C s | j | | | � d S( u8 Finish one request by instantiating RequestHandlerClass.N( u RequestHandlerClass( u selfu requestu client_address( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu finish_requestW s u BaseServer.finish_requestc C s | j | � d S( u3 Called to shutdown and close an individual request.N( u close_request( u selfu request( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu shutdown_request[ s u BaseServer.shutdown_requestc C s d S( u) Called to clean up an individual request.N( ( u selfu request( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu close_request_ s u BaseServer.close_requestc C sP t d d � t d d d �t | � d d l } | j � t d d � d S( ut Handle an error gracefully. May be overridden. The default is to print a traceback and continue. u -i( u4 Exception happened during processing of request fromu endu i N( u printu tracebacku print_exc( u selfu requestu client_addressu traceback( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu handle_errorc s u BaseServer.handle_errorN( u __name__u __module__u __qualname__u __doc__u Noneu timeoutu __init__u server_activateu serve_foreveru shutdownu service_actionsu handle_requestu _handle_request_noblocku handle_timeoutu verify_requestu process_requestu server_closeu finish_requestu shutdown_requestu close_requestu handle_error( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu BaseServer� s" + u BaseServerc B s� | Ee Z d Z d Z e j Z e j Z d Z d Z d d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d d � Z d S( u TCPServeru3 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 i c C sO t j | | | � t j | j | j � | _ | rK | j � | j � n d S( u/ Constructor. May be extended, do not override.N( u BaseServeru __init__u socketu address_familyu socket_typeu server_bindu server_activate( u selfu server_addressu RequestHandlerClassu bind_and_activate( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu __init__� s u TCPServer.__init__c C sQ | j r( | j j t j t j d � n | j j | j � | j j � | _ d S( uO Called by constructor to bind the socket. May be overridden. i N( u allow_reuse_addressu socketu setsockoptu SOL_SOCKETu SO_REUSEADDRu bindu server_addressu getsockname( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu server_bind� s u TCPServer.server_bindc C s | j j | j � d S( uS Called by constructor to activate the server. May be overridden. N( u socketu listenu request_queue_size( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu server_activate� s u TCPServer.server_activatec C s | j j � d S( uD Called to clean-up the server. May be overridden. N( u socketu close( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu server_close� s u TCPServer.server_closec C s | j j � S( uM Return socket file number. Interface required by select(). ( u socketu fileno( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu fileno� s u TCPServer.filenoc C s | j j � S( uY Get the request and client address from the socket. May be overridden. ( u socketu accept( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu get_request� s u TCPServer.get_requestc C s= y | j t j � Wn t j k r+ Yn X| j | � d S( u3 Called to shutdown and close an individual request.N( u shutdownu socketu SHUT_WRu erroru close_request( u selfu request( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu shutdown_request� s u TCPServer.shutdown_requestc C s | j � d S( u) Called to clean up an individual request.N( u close( u selfu request( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu close_request� s u TCPServer.close_requestNFT( u __name__u __module__u __qualname__u __doc__u socketu AF_INETu address_familyu SOCK_STREAMu socket_typeu request_queue_sizeu Falseu allow_reuse_addressu Trueu __init__u server_bindu server_activateu server_closeu filenou get_requestu shutdown_requestu close_request( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu TCPServerq s - c B s_ | Ee Z d Z d Z d Z e j Z d Z d d � Z d d � Z d d � Z d d � Z d S( u UDPServeru UDP server class.i c C s. | j j | j � \ } } | | j f | f S( N( u socketu recvfromu max_packet_size( u selfu datau client_addr( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu get_request� s u UDPServer.get_requestc C s d S( N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu server_activate� s u UDPServer.server_activatec C s | j | � d S( N( u close_request( u selfu request( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu shutdown_request� s u UDPServer.shutdown_requestc C s d S( N( ( u selfu request( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu close_request s u UDPServer.close_requestNF( u __name__u __module__u __qualname__u __doc__u Falseu allow_reuse_addressu socketu SOCK_DGRAMu socket_typeu max_packet_sizeu get_requestu server_activateu shutdown_requestu close_request( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu UDPServer� s c B s\ | Ee Z d Z d Z d Z d Z d Z d d � Z d d � Z d d � Z d d � Z d S( u ForkingMixInu5 Mix-in class to handle each request in a new process.i, i( c C sM | j d k r d Sx{ t | j � | j k r� y t j d d � \ } } Wn t j k rg d } Yn X| | j k r} q n | j j | � q Wx� | j D]� } y t j | t j � \ } } Wn t j k r� d } Yn X| s� q� n y | j j | � Wq� t k rD} z$ t d | j | | j f � � WYd d } ~ Xq� Xq� Wd S( u7 Internal routine to wait for children that have exited.Ni u %s. x=%d and list=%r( u active_childrenu Noneu lenu max_childrenu osu waitpidu erroru removeu WNOHANGu ValueErroru message( u selfu pidu statusu childu e( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu collect_children s, u ForkingMixIn.collect_childrenc C s | j � d S( un Wait for zombies after self.timeout seconds of inactivity. May be extended, do not override. N( u collect_children( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu handle_timeout- s u ForkingMixIn.handle_timeoutc C s | j � d S( u� Collect the zombie child processes regularly in the ForkingMixIn. service_actions is called in the BaseServer's serve_forver loop. N( u collect_children( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu service_actions4 s u ForkingMixIn.service_actionsc C s� t j � } | rN | j d k r- g | _ n | j j | � | j | � d Sy. | j | | � | j | � t j d � Wn: z! | j | | � | j | � Wd t j d � XYn Xd S( u- Fork a new subprocess to process the request.Ni i ( u osu forku active_childrenu Noneu appendu close_requestu finish_requestu shutdown_requestu _exitu handle_error( u selfu requestu client_addressu pid( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu process_request; s u ForkingMixIn.process_requestN( u __name__u __module__u __qualname__u __doc__u timeoutu Noneu active_childrenu max_childrenu collect_childrenu handle_timeoutu service_actionsu process_request( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ForkingMixIn s c B s8 | Ee Z d Z d Z d Z d d � Z d d � Z d S( u ThreadingMixInu4 Mix-in class to handle each request in a new thread.c C sM y! | j | | � | j | � Wn% | j | | � | j | � Yn Xd S( ug Same as in BaseServer but as a thread. In addition, exception handling is done here. N( u finish_requestu shutdown_requestu handle_error( u selfu requestu client_address( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu process_request_thread[ s u% ThreadingMixIn.process_request_threadc C s; t j d | j d | | f � } | j | _ | j � d S( u* Start a new thread to process the request.u targetu argsN( u threadingu Threadu process_request_threadu daemon_threadsu daemonu start( u selfu requestu client_addressu t( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu process_requesth s u ThreadingMixIn.process_requestNF( u __name__u __module__u __qualname__u __doc__u Falseu daemon_threadsu process_request_threadu process_request( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ThreadingMixInT s c B s | Ee Z d Z d S( u ForkingUDPServerN( u __name__u __module__u __qualname__( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ForkingUDPServerp s c B s | Ee Z d Z d S( u ForkingTCPServerN( u __name__u __module__u __qualname__( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ForkingTCPServerq s c B s | Ee Z d Z d S( u ThreadingUDPServerN( u __name__u __module__u __qualname__( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ThreadingUDPServers s c B s | Ee Z d Z d S( u ThreadingTCPServerN( u __name__u __module__u __qualname__( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ThreadingTCPServert s c B s | Ee Z d Z e j Z d S( u UnixStreamServerN( u __name__u __module__u __qualname__u socketu AF_UNIXu address_family( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu UnixStreamServerx s c B s | Ee Z d Z e j Z d S( u UnixDatagramServerN( u __name__u __module__u __qualname__u socketu AF_UNIXu address_family( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu UnixDatagramServer{ s c B s | Ee Z d Z d S( u ThreadingUnixStreamServerN( u __name__u __module__u __qualname__( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ThreadingUnixStreamServer~ s c B s | Ee Z d Z d S( u ThreadingUnixDatagramServerN( u __name__u __module__u __qualname__( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu ThreadingUnixDatagramServer� s c B sJ | Ee Z d Z d Z d d � Z d d � Z d d � Z d d � Z d S( u BaseRequestHandleru� 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. c C sE | | _ | | _ | | _ | j � z | j � Wd | j � Xd S( N( u requestu client_addressu serveru setupu handleu finish( u selfu requestu client_addressu server( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu __init__� s u BaseRequestHandler.__init__c C s d S( N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu setup� s u BaseRequestHandler.setupc C s d S( N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu handle� s u BaseRequestHandler.handlec C s d S( N( ( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu finish� s u BaseRequestHandler.finishN( u __name__u __module__u __qualname__u __doc__u __init__u setupu handleu finish( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu BaseRequestHandler� s c B sJ | Ee Z d Z d Z d Z d Z d Z d Z d d � Z d d � Z d S( u StreamRequestHandleru4 Define self.rfile and self.wfile for stream sockets.i i c C s� | j | _ | j d k r1 | j j | j � n | j rY | j j t j t j d � n | j j d | j � | _ | j j d | j � | _ d S( Nu rbu wbT( u requestu connectionu timeoutu Noneu settimeoutu disable_nagle_algorithmu setsockoptu socketu IPPROTO_TCPu TCP_NODELAYu Trueu makefileu rbufsizeu rfileu wbufsizeu wfile( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu setup� s u StreamRequestHandler.setupc C sV | j j s8 y | j j � Wq8 t j k r4 Yq8 Xn | j j � | j j � d S( N( u wfileu closedu flushu socketu erroru closeu rfile( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu finish� s u StreamRequestHandler.finishNi����F( u __name__u __module__u __qualname__u __doc__u rbufsizeu wbufsizeu Noneu timeoutu Falseu disable_nagle_algorithmu setupu finish( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu StreamRequestHandler� s c B s2 | Ee Z d Z d Z d d � Z d d � Z d S( u DatagramRequestHandleru6 Define self.rfile and self.wfile for datagram sockets.c C sG d d l m } | j \ | _ | _ | | j � | _ | � | _ d S( Ni ( u BytesIO( u iou BytesIOu requestu packetu socketu rfileu wfile( u selfu BytesIO( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu setup� s u DatagramRequestHandler.setupc C s# | j j | j j � | j � d S( N( u socketu sendtou wfileu getvalueu client_address( u self( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu finish� s u DatagramRequestHandler.finishN( u __name__u __module__u __qualname__u __doc__u setupu finish( u __locals__( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu DatagramRequestHandler� s ( u __doc__u __version__u socketu selectu sysu osu errnou threadingu ImportErroru dummy_threadingu __all__u hasattru extendu _eintr_retryu BaseServeru TCPServeru UDPServeru ForkingMixInu ThreadingMixInu ForkingUDPServeru ForkingTCPServeru ThreadingUDPServeru ThreadingTCPServeru UnixStreamServeru UnixDatagramServeru ThreadingUnixStreamServeru ThreadingUnixDatagramServeru BaseRequestHandleru StreamRequestHandleru DatagramRequestHandler( ( ( u1 /opt/alt/python33/lib64/python3.3/socketserver.pyu <module>x sH �zO .+
Save File
Cancel