home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1473 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.5 KB  |  227 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import time
  5.  
  6. class ServerAdapter(object):
  7.     
  8.     def __init__(self, bus, httpserver = None, bind_addr = None):
  9.         self.bus = bus
  10.         self.httpserver = httpserver
  11.         self.bind_addr = bind_addr
  12.         self.interrupt = None
  13.         self.running = False
  14.  
  15.     
  16.     def subscribe(self):
  17.         self.bus.subscribe('start', self.start)
  18.         self.bus.subscribe('stop', self.stop)
  19.  
  20.     
  21.     def unsubscribe(self):
  22.         self.bus.unsubscribe('start', self.start)
  23.         self.bus.unsubscribe('stop', self.stop)
  24.  
  25.     
  26.     def start(self):
  27.         if isinstance(self.bind_addr, tuple):
  28.             (host, port) = self.bind_addr
  29.             on_what = '%s:%s' % (host, port)
  30.         else:
  31.             on_what = 'socket file: %s' % self.bind_addr
  32.         if self.running:
  33.             self.bus.log('Already serving on %s' % on_what)
  34.             return None
  35.         self.interrupt = None
  36.         if not self.httpserver:
  37.             raise ValueError('No HTTP server has been created.')
  38.         self.httpserver
  39.         if isinstance(self.bind_addr, tuple):
  40.             wait_for_free_port(*self.bind_addr)
  41.         
  42.         import threading
  43.         t = threading.Thread(target = self._start_http_thread)
  44.         t.setName('HTTPServer ' + t.getName())
  45.         t.start()
  46.         self.wait()
  47.         self.running = True
  48.         self.bus.log('Serving on %s' % on_what)
  49.  
  50.     start.priority = 75
  51.     
  52.     def _start_http_thread(self):
  53.         
  54.         try:
  55.             self.httpserver.start()
  56.         except KeyboardInterrupt:
  57.             exc = None
  58.             self.bus.log('<Ctrl-C> hit: shutting down HTTP server')
  59.             self.interrupt = exc
  60.             self.bus.exit()
  61.         except SystemExit:
  62.             exc = None
  63.             self.bus.log('SystemExit raised: shutting down HTTP server')
  64.             self.interrupt = exc
  65.             self.bus.exit()
  66.             raise 
  67.         except:
  68.             import sys
  69.             self.interrupt = sys.exc_info()[1]
  70.             self.bus.log('Error in HTTP server: shutting down', traceback = True, level = 40)
  71.             self.bus.exit()
  72.             raise 
  73.  
  74.  
  75.     
  76.     def wait(self):
  77.         while not getattr(self.httpserver, 'ready', False):
  78.             if self.interrupt:
  79.                 raise self.interrupt
  80.             self.interrupt
  81.             time.sleep(0.1)
  82.         if isinstance(self.bind_addr, tuple):
  83.             (host, port) = self.bind_addr
  84.             wait_for_occupied_port(host, port)
  85.         
  86.  
  87.     
  88.     def stop(self):
  89.         if self.running:
  90.             self.httpserver.stop()
  91.             if isinstance(self.bind_addr, tuple):
  92.                 wait_for_free_port(*self.bind_addr)
  93.             
  94.             self.running = False
  95.             self.bus.log('HTTP Server %s shut down' % self.httpserver)
  96.         else:
  97.             self.bus.log('HTTP Server %s already shut down' % self.httpserver)
  98.  
  99.     stop.priority = 25
  100.     
  101.     def restart(self):
  102.         self.stop()
  103.         self.start()
  104.  
  105.  
  106.  
  107. class FlupFCGIServer(object):
  108.     
  109.     def __init__(self, *args, **kwargs):
  110.         self.args = args
  111.         self.kwargs = kwargs
  112.         self.ready = False
  113.  
  114.     
  115.     def start(self):
  116.         WSGIServer = WSGIServer
  117.         import flup.server.fcgi
  118.         self.fcgiserver = WSGIServer(*self.args, **self.kwargs)
  119.         
  120.         self.fcgiserver._installSignalHandlers = lambda : pass
  121.         self.fcgiserver._oldSIGs = []
  122.         self.ready = True
  123.         self.fcgiserver.run()
  124.  
  125.     
  126.     def stop(self):
  127.         self.fcgiserver._keepGoing = False
  128.         self.fcgiserver._threadPool.maxSpare = self.fcgiserver._threadPool._idleCount
  129.         self.ready = False
  130.  
  131.  
  132.  
  133. class FlupSCGIServer(object):
  134.     
  135.     def __init__(self, *args, **kwargs):
  136.         self.args = args
  137.         self.kwargs = kwargs
  138.         self.ready = False
  139.  
  140.     
  141.     def start(self):
  142.         WSGIServer = WSGIServer
  143.         import flup.server.scgi
  144.         self.scgiserver = WSGIServer(*self.args, **self.kwargs)
  145.         
  146.         self.scgiserver._installSignalHandlers = lambda : pass
  147.         self.scgiserver._oldSIGs = []
  148.         self.ready = True
  149.         self.scgiserver.run()
  150.  
  151.     
  152.     def stop(self):
  153.         self.ready = False
  154.         self.scgiserver._keepGoing = False
  155.         self.scgiserver._threadPool.maxSpare = 0
  156.  
  157.  
  158.  
  159. def client_host(server_host):
  160.     if server_host == '0.0.0.0':
  161.         return '127.0.0.1'
  162.     if server_host == '::':
  163.         return '::1'
  164.     return server_host
  165.  
  166.  
  167. def check_port(host, port, timeout = 1):
  168.     if not host:
  169.         raise ValueError("Host values of '' or None are not allowed.")
  170.     host
  171.     host = client_host(host)
  172.     port = int(port)
  173.     import socket
  174.     for res in socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM):
  175.         (af, socktype, proto, canonname, sa) = res
  176.         s = None
  177.         
  178.         try:
  179.             s = socket.socket(af, socktype, proto)
  180.             s.settimeout(timeout)
  181.             s.connect((host, port))
  182.             s.close()
  183.             raise IOError('Port %s is in use on %s; perhaps the previous httpserver did not shut down properly.' % (repr(port), repr(host)))
  184.         continue
  185.         except socket.error:
  186.             if s:
  187.                 s.close()
  188.             
  189.             s
  190.         
  191.  
  192.     
  193.  
  194.  
  195. def wait_for_free_port(host, port):
  196.     if not host:
  197.         raise ValueError("Host values of '' or None are not allowed.")
  198.     host
  199.     for trial in xrange(50):
  200.         
  201.         try:
  202.             check_port(host, port, timeout = 0.2)
  203.         except IOError:
  204.             time.sleep(0.2)
  205.             continue
  206.  
  207.         return None
  208.     
  209.     raise IOError('Port %r not free on %r' % (port, host))
  210.  
  211.  
  212. def wait_for_occupied_port(host, port):
  213.     if not host:
  214.         raise ValueError("Host values of '' or None are not allowed.")
  215.     host
  216.     for trial in xrange(50):
  217.         
  218.         try:
  219.             check_port(host, port)
  220.         except IOError:
  221.             return None
  222.  
  223.         time.sleep(0.1)
  224.     
  225.     raise IOError('Port %r not bound on %r' % (port, host))
  226.  
  227.