home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / SocketServer.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  11.0 KB  |  396 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __version__ = '0.4'
  5. import socket
  6. import select
  7. import sys
  8. import os
  9.  
  10. try:
  11.     import threading
  12. except ImportError:
  13.     import dummy_threading as threading
  14.  
  15. __all__ = [
  16.     'TCPServer',
  17.     'UDPServer',
  18.     'ForkingUDPServer',
  19.     'ForkingTCPServer',
  20.     'ThreadingUDPServer',
  21.     'ThreadingTCPServer',
  22.     'BaseRequestHandler',
  23.     'StreamRequestHandler',
  24.     'DatagramRequestHandler',
  25.     'ThreadingMixIn',
  26.     'ForkingMixIn']
  27. if hasattr(socket, 'AF_UNIX'):
  28.     __all__.extend([
  29.         'UnixStreamServer',
  30.         'UnixDatagramServer',
  31.         'ThreadingUnixStreamServer',
  32.         'ThreadingUnixDatagramServer'])
  33.  
  34.  
  35. class BaseServer:
  36.     timeout = None
  37.     
  38.     def __init__(self, server_address, RequestHandlerClass):
  39.         self.server_address = server_address
  40.         self.RequestHandlerClass = RequestHandlerClass
  41.         self._BaseServer__is_shut_down = threading.Event()
  42.         self._BaseServer__serving = False
  43.  
  44.     
  45.     def server_activate(self):
  46.         pass
  47.  
  48.     
  49.     def serve_forever(self, poll_interval = 0.5):
  50.         self._BaseServer__serving = True
  51.         self._BaseServer__is_shut_down.clear()
  52.         while self._BaseServer__serving:
  53.             (r, w, e) = select.select([
  54.                 self], [], [], poll_interval)
  55.             if r:
  56.                 self._handle_request_noblock()
  57.                 continue
  58.         self._BaseServer__is_shut_down.set()
  59.  
  60.     
  61.     def shutdown(self):
  62.         self._BaseServer__serving = False
  63.         self._BaseServer__is_shut_down.wait()
  64.  
  65.     
  66.     def handle_request(self):
  67.         timeout = self.socket.gettimeout()
  68.         if timeout is None:
  69.             timeout = self.timeout
  70.         elif self.timeout is not None:
  71.             timeout = min(timeout, self.timeout)
  72.         
  73.         fd_sets = select.select([
  74.             self], [], [], timeout)
  75.         if not fd_sets[0]:
  76.             self.handle_timeout()
  77.             return None
  78.         self._handle_request_noblock()
  79.  
  80.     
  81.     def _handle_request_noblock(self):
  82.         
  83.         try:
  84.             (request, client_address) = self.get_request()
  85.         except socket.error:
  86.             return None
  87.  
  88.         if self.verify_request(request, client_address):
  89.             
  90.             try:
  91.                 self.process_request(request, client_address)
  92.             self.handle_error(request, client_address)
  93.             self.close_request(request)
  94.  
  95.         
  96.  
  97.     
  98.     def handle_timeout(self):
  99.         pass
  100.  
  101.     
  102.     def verify_request(self, request, client_address):
  103.         return True
  104.  
  105.     
  106.     def process_request(self, request, client_address):
  107.         self.finish_request(request, client_address)
  108.         self.close_request(request)
  109.  
  110.     
  111.     def server_close(self):
  112.         pass
  113.  
  114.     
  115.     def finish_request(self, request, client_address):
  116.         self.RequestHandlerClass(request, client_address, self)
  117.  
  118.     
  119.     def close_request(self, request):
  120.         pass
  121.  
  122.     
  123.     def handle_error(self, request, client_address):
  124.         print '-' * 40
  125.         print 'Exception happened during processing of request from', client_address
  126.         import traceback
  127.         traceback.print_exc()
  128.         print '-' * 40
  129.  
  130.  
  131.  
  132. class TCPServer(BaseServer):
  133.     address_family = socket.AF_INET
  134.     socket_type = socket.SOCK_STREAM
  135.     request_queue_size = 5
  136.     allow_reuse_address = False
  137.     
  138.     def __init__(self, server_address, RequestHandlerClass, bind_and_activate = True):
  139.         BaseServer.__init__(self, server_address, RequestHandlerClass)
  140.         self.socket = socket.socket(self.address_family, self.socket_type)
  141.         if bind_and_activate:
  142.             self.server_bind()
  143.             self.server_activate()
  144.         
  145.  
  146.     
  147.     def server_bind(self):
  148.         if self.allow_reuse_address:
  149.             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  150.         
  151.         self.socket.bind(self.server_address)
  152.         self.server_address = self.socket.getsockname()
  153.  
  154.     
  155.     def server_activate(self):
  156.         self.socket.listen(self.request_queue_size)
  157.  
  158.     
  159.     def server_close(self):
  160.         self.socket.close()
  161.  
  162.     
  163.     def fileno(self):
  164.         return self.socket.fileno()
  165.  
  166.     
  167.     def get_request(self):
  168.         return self.socket.accept()
  169.  
  170.     
  171.     def close_request(self, request):
  172.         request.close()
  173.  
  174.  
  175.  
  176. class UDPServer(TCPServer):
  177.     allow_reuse_address = False
  178.     socket_type = socket.SOCK_DGRAM
  179.     max_packet_size = 8192
  180.     
  181.     def get_request(self):
  182.         (data, client_addr) = self.socket.recvfrom(self.max_packet_size)
  183.         return ((data, self.socket), client_addr)
  184.  
  185.     
  186.     def server_activate(self):
  187.         pass
  188.  
  189.     
  190.     def close_request(self, request):
  191.         pass
  192.  
  193.  
  194.  
  195. class ForkingMixIn:
  196.     timeout = 300
  197.     active_children = None
  198.     max_children = 40
  199.     
  200.     def collect_children(self):
  201.         if self.active_children is None:
  202.             return None
  203.         while len(self.active_children) >= self.max_children:
  204.             
  205.             try:
  206.                 (pid, status) = os.waitpid(0, options = 0)
  207.             except os.error:
  208.                 self.active_children is None
  209.                 self.active_children is None
  210.                 pid = None
  211.             except:
  212.                 self.active_children is None
  213.  
  214.             if pid not in self.active_children:
  215.                 continue
  216.             
  217.             self.active_children.remove(pid)
  218.         for child in self.active_children:
  219.             
  220.             try:
  221.                 (pid, status) = os.waitpid(child, os.WNOHANG)
  222.             except os.error:
  223.                 pid = None
  224.  
  225.             if not pid:
  226.                 continue
  227.             
  228.             
  229.             try:
  230.                 self.active_children.remove(pid)
  231.             continue
  232.             except ValueError:
  233.                 e = None
  234.                 raise ValueError('%s. x=%d and list=%r' % (e.message, pid, self.active_children))
  235.                 continue
  236.             
  237.  
  238.         
  239.  
  240.     
  241.     def handle_timeout(self):
  242.         self.collect_children()
  243.  
  244.     
  245.     def process_request(self, request, client_address):
  246.         self.collect_children()
  247.         pid = os.fork()
  248.         if pid:
  249.             if self.active_children is None:
  250.                 self.active_children = []
  251.             
  252.             self.active_children.append(pid)
  253.             self.close_request(request)
  254.             return None
  255.         
  256.         try:
  257.             self.finish_request(request, client_address)
  258.             os._exit(0)
  259.         except:
  260.             pid
  261.             
  262.             try:
  263.                 self.handle_error(request, client_address)
  264.             finally:
  265.                 os._exit(1)
  266.  
  267.  
  268.  
  269.  
  270.  
  271. class ThreadingMixIn:
  272.     daemon_threads = False
  273.     
  274.     def process_request_thread(self, request, client_address):
  275.         
  276.         try:
  277.             self.finish_request(request, client_address)
  278.             self.close_request(request)
  279.         except:
  280.             self.handle_error(request, client_address)
  281.             self.close_request(request)
  282.  
  283.  
  284.     
  285.     def process_request(self, request, client_address):
  286.         t = threading.Thread(target = self.process_request_thread, args = (request, client_address))
  287.         if self.daemon_threads:
  288.             t.setDaemon(1)
  289.         
  290.         t.start()
  291.  
  292.  
  293.  
  294. class ForkingUDPServer(ForkingMixIn, UDPServer):
  295.     pass
  296.  
  297.  
  298. class ForkingTCPServer(ForkingMixIn, TCPServer):
  299.     pass
  300.  
  301.  
  302. class ThreadingUDPServer(ThreadingMixIn, UDPServer):
  303.     pass
  304.  
  305.  
  306. class ThreadingTCPServer(ThreadingMixIn, TCPServer):
  307.     pass
  308.  
  309. if hasattr(socket, 'AF_UNIX'):
  310.     
  311.     class UnixStreamServer(TCPServer):
  312.         address_family = socket.AF_UNIX
  313.  
  314.     
  315.     class UnixDatagramServer(UDPServer):
  316.         address_family = socket.AF_UNIX
  317.  
  318.     
  319.     class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer):
  320.         pass
  321.  
  322.     
  323.     class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer):
  324.         pass
  325.  
  326.  
  327.  
  328. class BaseRequestHandler:
  329.     
  330.     def __init__(self, request, client_address, server):
  331.         self.request = request
  332.         self.client_address = client_address
  333.         self.server = server
  334.         
  335.         try:
  336.             self.setup()
  337.             self.handle()
  338.             self.finish()
  339.         finally:
  340.             sys.exc_traceback = None
  341.  
  342.  
  343.     
  344.     def setup(self):
  345.         pass
  346.  
  347.     
  348.     def handle(self):
  349.         pass
  350.  
  351.     
  352.     def finish(self):
  353.         pass
  354.  
  355.  
  356.  
  357. class StreamRequestHandler(BaseRequestHandler):
  358.     rbufsize = -1
  359.     wbufsize = 0
  360.     
  361.     def setup(self):
  362.         self.connection = self.request
  363.         self.rfile = self.connection.makefile('rb', self.rbufsize)
  364.         self.wfile = self.connection.makefile('wb', self.wbufsize)
  365.  
  366.     
  367.     def finish(self):
  368.         if not self.wfile.closed:
  369.             self.wfile.flush()
  370.         
  371.         self.wfile.close()
  372.         self.rfile.close()
  373.  
  374.  
  375.  
  376. class DatagramRequestHandler(BaseRequestHandler):
  377.     
  378.     def setup(self):
  379.         
  380.         try:
  381.             StringIO = StringIO
  382.             import cStringIO
  383.         except ImportError:
  384.             StringIO = StringIO
  385.             import StringIO
  386.  
  387.         (self.packet, self.socket) = self.request
  388.         self.rfile = StringIO(self.packet)
  389.         self.wfile = StringIO()
  390.  
  391.     
  392.     def finish(self):
  393.         self.socket.sendto(self.wfile.getvalue(), self.client_address)
  394.  
  395.  
  396.