home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / common / asynchttp / server.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  11.8 KB  |  366 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import io
  5. import rfc822
  6. import common
  7. import urlparse
  8. import logging
  9. import util.Events as events
  10. log = logging.getLogger('httpserver')
  11. import collections
  12. from common.asynchttp.httptypes import HTTPRequest
  13. CRLF = '\r\n'
  14.  
  15. def is_re(x):
  16.     return False
  17.  
  18.  
  19. class HTTPServerManager(object):
  20.     
  21.     def __init__(self):
  22.         self.resources = collections.defaultdict(list)
  23.         self.clients = collections.defaultdict(list)
  24.         self.servers = { }
  25.  
  26.     
  27.     def serve(self, pattern, handler_factory, host = '', port = 80):
  28.         self.resources[(host, port)].append((pattern, handler_factory))
  29.         (shost, sport) = self.bind(host, port)
  30.         if not shost:
  31.             pass
  32.         if not sport:
  33.             pass
  34.         log.info('Now serving: http://%s:%s%s -> %r', 'localhost', 80, pattern, handler_factory)
  35.         return (shost, sport)
  36.  
  37.     
  38.     def stop_serving(self, pattern, host, port):
  39.         p = None
  40.         hf = None
  41.         for p, hf in self.resources[(host, port)]:
  42.             if p == pattern:
  43.                 break
  44.                 continue
  45.         else:
  46.             p = None
  47.             hf = None
  48.         if hf is hf:
  49.             pass
  50.         elif not hf is None:
  51.             
  52.             try:
  53.                 self.resources[(host, port)].remove((p, hf))
  54.             except ValueError:
  55.                 pass
  56.             except:
  57.                 None<EXCEPTION MATCH>ValueError
  58.             
  59.  
  60.         None<EXCEPTION MATCH>ValueError
  61.         if not host:
  62.             pass
  63.         if not port:
  64.             pass
  65.         log.info('No longer serving http://%s:%s%s', 'localhost', 80, pattern)
  66.         self._check_resources()
  67.  
  68.     
  69.     def _check_resources(self):
  70.         for hostport in self.resources.keys():
  71.             if not self.resources[hostport]:
  72.                 self.resources.pop(hostport)
  73.                 self.shutdown_server(self.servers.pop(hostport))
  74.                 continue
  75.         
  76.         if not self.servers:
  77.             log.info('Shutting down http server, nothing left to serve!')
  78.             self.shutdown()
  79.         
  80.  
  81.     
  82.     def bind(self, host = '', port = 80):
  83.         if (host, port) not in self.servers:
  84.             srv = HTTPServerSocket()
  85.             srv.bind_event('on_connection', self.on_client)
  86.             srv.bind(host, port)
  87.             self.servers[(host, port)] = srv
  88.             srv.listen(5)
  89.         
  90.         return self.servers[(host, port)].getsockname()
  91.  
  92.     
  93.     def shutdown(self):
  94.         log.info('Shutting down all servers')
  95.         for addr in self.servers.keys():
  96.             self.shutdown_server(self.servers.pop(addr))
  97.         
  98.         for cli in self.clients.keys():
  99.             clients = self.clients.pop(cli)
  100.             while clients:
  101.                 self.shutdown_client(clients.pop(0))
  102.         
  103.         self.resources.clear()
  104.  
  105.     
  106.     def shutdown_server(self, srv):
  107.         srv.unbind('on_connection', self.on_client)
  108.         srv.close()
  109.  
  110.     
  111.     def shutdown_client(self, cli):
  112.         cli.unbind('on_request', self.process_request)
  113.         cli.unbind('on_close', self.on_client_close)
  114.         cli.close()
  115.  
  116.     
  117.     def on_client(self, srvaddr, client_address, conn):
  118.         client = HTTPRequestGatherer(conn, client_address, srvaddr)
  119.         client.bind_event('on_request', self.process_request)
  120.         client.bind_event('on_close', self.on_client_close)
  121.         self.clients[(srvaddr, client_address)].append(client)
  122.         client.can_process = True
  123.  
  124.     
  125.     def on_client_close(self, client):
  126.         
  127.         try:
  128.             self.clients[(client.server_address, client.client_address)].remove(client)
  129.         except ValueError:
  130.             pass
  131.  
  132.         client.unbind('on_request', self.process_request)
  133.         client.unbind('on_close', self.on_client_close)
  134.  
  135.     
  136.     def process_request(self, srvaddr, client_address, client, request):
  137.         for pattern, handler_factory in self.resources[srvaddr]:
  138.             if not self.match(pattern, request):
  139.                 continue
  140.             
  141.             
  142.             try:
  143.                 self.handle(handler_factory, srvaddr, client_address, client, request)
  144.             continue
  145.             except Exception:
  146.                 e = None
  147.                 log.error('Error processing request %r: %r', request, e)
  148.                 return None
  149.             
  150.  
  151.         
  152.  
  153.     
  154.     def handle(self, handler_factory, srvaddr, client_address, client, request):
  155.         handler = handler_factory(srvaddr, client_address)
  156.         handler.handle(client, request)
  157.  
  158.     
  159.     def match(self, pattern, request):
  160.         if isinstance(pattern, bytes):
  161.             url = request.get_full_url()
  162.             parsed = urlparse.urlparse(url)
  163.             if parsed.path == pattern:
  164.                 return True
  165.             dir = pattern
  166.             if not dir.endswith('/'):
  167.                 dir = dir + '/'
  168.             
  169.             if parsed.path.startswith(dir):
  170.                 return True
  171.         elif False and is_re(pattern):
  172.             pass
  173.         elif callable(pattern):
  174.             return pattern(request)
  175.         return False
  176.  
  177.  
  178.  
  179. class HTTPRequestGatherer(common.socket, events.EventMixin):
  180.     events = events.EventMixin.events | set(('on_request', 'on_close'))
  181.     
  182.     def __init__(self, conn, client_address, server_address):
  183.         events.EventMixin.__init__(self)
  184.         common.socket.__init__(self, conn)
  185.         self.can_process = False
  186.         self.client_address = client_address
  187.         self.server_address = server_address
  188.         self.set_terminator(CRLF * 2)
  189.         self.buffer = []
  190.         self.data = None
  191.         self._request = None
  192.         self._headers = None
  193.  
  194.     
  195.     def readable(self):
  196.         if self.can_process:
  197.             pass
  198.         return common.socket.readable(self)
  199.  
  200.     
  201.     def collect_incoming_data(self, data):
  202.         self.buffer.append(data)
  203.  
  204.     
  205.     def found_terminator(self):
  206.         self.data = ''.join(self.buffer)
  207.         self.buffer[:] = []
  208.         if self.terminator == CRLF * 2:
  209.             self.headers_complete()
  210.         else:
  211.             self.body_complete()
  212.  
  213.     
  214.     def headers_complete(self):
  215.         header_fp = io.BytesIO(self.data)
  216.         self.data = None
  217.         start_line = header_fp.readline()
  218.         (self.method, self.path, self.version) = self._parse_start_line(start_line)
  219.         self._headers = headers = rfc822.Message(header_fp)
  220.         self._normalize_headers()
  221.         clen = headers.getheader('Content-Length')
  222.         if clen is not None:
  223.             if clen != 0:
  224.                 self.set_terminator(clen)
  225.                 return None
  226.         
  227.         self.body_complete()
  228.  
  229.     
  230.     def _parse_start_line(self, line):
  231.         return line.split()
  232.  
  233.     
  234.     def _normalize_headers(self):
  235.         d = { }
  236.         for key in self._headers.keys():
  237.             d[key] = '; '.join(self._headers.getheaders(key))
  238.         
  239.         self._headers = d
  240.  
  241.     
  242.     def body_complete(self):
  243.         uri = urlparse.urlparse(self.path)
  244.         d = uri._asdict()
  245.         if not uri.netloc:
  246.             d.update(netloc = '%s:%s' % self.server_address)
  247.         
  248.         if not uri.scheme:
  249.             d.update(scheme = 'http')
  250.         
  251.         uri = urlparse.ParseResult(**d).geturl()
  252.         body = self.data
  253.         self.data = ''
  254.         request = HTTPRequest(uri, body, self._headers, method = self.method)
  255.         self.path = None
  256.         self.method = None
  257.         self.version = None
  258.         self._headers = None
  259.         self.event('on_request', self.server_address, self.client_address, self, request)
  260.  
  261.     
  262.     def close(self):
  263.         common.socket.close(self)
  264.         self.event('on_close', self)
  265.  
  266.  
  267.  
  268. class HTTPServerSocket(common.socket, events.EventMixin):
  269.     events = events.EventMixin.events | set(('on_connection',))
  270.     
  271.     def __init__(self):
  272.         events.EventMixin.__init__(self)
  273.         common.socket.__init__(self)
  274.         self.socket = None
  275.  
  276.     
  277.     def bind(self, host = '', port = 80):
  278.         self._hostport = (host, port)
  279.         self.make_socket(proxy = False)
  280.         common.socket.bind(self, (host, port))
  281.         return self.getsockname()
  282.  
  283.     
  284.     def getsockname(self):
  285.         return self.socket.getsockname()
  286.  
  287.     
  288.     def handle_accept(self):
  289.         (conn, address) = self.accept()
  290.         self.event('on_connection', self._hostport, address, conn)
  291.  
  292.  
  293.  
  294. class DefaultHandler(object):
  295.     
  296.     def __init__(self, srv_addr, client_addr):
  297.         self.srv_addr = srv_addr
  298.         self.client_addr = client_addr
  299.  
  300.     
  301.     def handle(self, client, request):
  302.         log.info('Got request! %r', request)
  303.         client.push('HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 5\r\n\r\nbyeee')
  304.         client.close()
  305.  
  306.  
  307. _default_server_manager = None
  308.  
  309. def serve(pattern, handler_factory, host = '', port = 0):
  310.     global _default_server_manager
  311.     if _default_server_manager is None:
  312.         import atexit
  313.         _default_server_manager = HTTPServerManager()
  314.         atexit.register(_default_server_manager.shutdown)
  315.     
  316.     return _default_server_manager.serve(pattern, handler_factory, host, port)
  317.  
  318.  
  319. def stop_serving(pattern, host, port):
  320.     if _default_server_manager is None:
  321.         return None
  322.     return _default_server_manager.stop_serving(pattern, host, port)
  323.  
  324.  
  325. def shutdown():
  326.     global _default_server_manager
  327.     if _default_server_manager is None:
  328.         return None
  329.     _default_server_manager.shutdown()
  330.     _default_server_manager = None
  331.  
  332. if __name__ == '__main__':
  333.     logging.basicConfig()
  334.     import AsyncoreThread as AT
  335.     AT.start()
  336.     srv = HTTPServerManager()
  337.     
  338.     class ClosingHandler(DefaultHandler):
  339.         
  340.         def handle(self, client, request):
  341.             print 'closing!'
  342.             client.push('HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nserver has been shutdown')
  343.             client.close()
  344.             srv.shutdown()
  345.  
  346.  
  347.     (host, port) = srv.serve('/close', ClosingHandler, host = '', port = 0)
  348.     srv.serve((lambda : True), DefaultHandler, host = '', port = 0)
  349.     print AT.net_thread.map
  350.     import time
  351.     time.sleep(1)
  352.     import urllib2
  353.     
  354.     try:
  355.         for url in ('http://localhost:{port}/foo/bar', 'http://localhost:{port}/close', 'http://localhost:{port}/blah'):
  356.             x = urllib2.urlopen(url.format(**locals()))
  357.             print x.read()
  358.             x.close()
  359.     except Exception:
  360.         e = None
  361.         print 'urlopenerror:', e
  362.  
  363.     time.sleep(1)
  364.     AT.join()
  365.  
  366.