home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2846 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  9.5 KB  |  324 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from types import StringType
  5. from util import FileWrapper, guess_scheme, is_hop_by_hop
  6. from headers import Headers
  7. import sys
  8. import os
  9. import time
  10. __all__ = [
  11.     'BaseHandler',
  12.     'SimpleHandler',
  13.     'BaseCGIHandler',
  14.     'CGIHandler']
  15.  
  16. try:
  17.     dict
  18. except NameError:
  19.     
  20.     def dict(items):
  21.         d = { }
  22.         for k, v in items:
  23.             d[k] = v
  24.         
  25.         return d
  26.  
  27.  
  28. _weekdayname = [
  29.     'Mon',
  30.     'Tue',
  31.     'Wed',
  32.     'Thu',
  33.     'Fri',
  34.     'Sat',
  35.     'Sun']
  36. _monthname = [
  37.     None,
  38.     'Jan',
  39.     'Feb',
  40.     'Mar',
  41.     'Apr',
  42.     'May',
  43.     'Jun',
  44.     'Jul',
  45.     'Aug',
  46.     'Sep',
  47.     'Oct',
  48.     'Nov',
  49.     'Dec']
  50.  
  51. def format_date_time(timestamp):
  52.     (year, month, day, hh, mm, ss, wd, y, z) = time.gmtime(timestamp)
  53.     return '%s, %02d %3s %4d %02d:%02d:%02d GMT' % (_weekdayname[wd], day, _monthname[month], year, hh, mm, ss)
  54.  
  55.  
  56. class BaseHandler:
  57.     wsgi_version = (1, 0)
  58.     wsgi_multithread = True
  59.     wsgi_multiprocess = True
  60.     wsgi_run_once = False
  61.     origin_server = True
  62.     http_version = '1.0'
  63.     server_software = None
  64.     os_environ = dict(os.environ.items())
  65.     wsgi_file_wrapper = FileWrapper
  66.     headers_class = Headers
  67.     traceback_limit = None
  68.     error_status = '500 Dude, this is whack!'
  69.     error_headers = [
  70.         ('Content-Type', 'text/plain')]
  71.     error_body = 'A server error occurred.  Please contact the administrator.'
  72.     status = None
  73.     result = None
  74.     headers_sent = False
  75.     headers = None
  76.     bytes_sent = 0
  77.     
  78.     def run(self, application):
  79.         
  80.         try:
  81.             self.setup_environ()
  82.             self.result = application(self.environ, self.start_response)
  83.             self.finish_response()
  84.         except:
  85.             
  86.             try:
  87.                 self.handle_error()
  88.             self.close()
  89.             raise 
  90.  
  91.  
  92.  
  93.     
  94.     def setup_environ(self):
  95.         env = self.environ = self.os_environ.copy()
  96.         self.add_cgi_vars()
  97.         env['wsgi.input'] = self.get_stdin()
  98.         env['wsgi.errors'] = self.get_stderr()
  99.         env['wsgi.version'] = self.wsgi_version
  100.         env['wsgi.run_once'] = self.wsgi_run_once
  101.         env['wsgi.url_scheme'] = self.get_scheme()
  102.         env['wsgi.multithread'] = self.wsgi_multithread
  103.         env['wsgi.multiprocess'] = self.wsgi_multiprocess
  104.         if self.wsgi_file_wrapper is not None:
  105.             env['wsgi.file_wrapper'] = self.wsgi_file_wrapper
  106.         
  107.         if self.origin_server and self.server_software:
  108.             env.setdefault('SERVER_SOFTWARE', self.server_software)
  109.         
  110.  
  111.     
  112.     def finish_response(self):
  113.         if not self.result_is_file() or not self.sendfile():
  114.             for data in self.result:
  115.                 self.write(data)
  116.             
  117.             self.finish_content()
  118.         
  119.         self.close()
  120.  
  121.     
  122.     def get_scheme(self):
  123.         return guess_scheme(self.environ)
  124.  
  125.     
  126.     def set_content_length(self):
  127.         
  128.         try:
  129.             blocks = len(self.result)
  130.         except (TypeError, AttributeError, NotImplementedError):
  131.             pass
  132.  
  133.         if blocks == 1:
  134.             self.headers['Content-Length'] = str(self.bytes_sent)
  135.             return None
  136.  
  137.     
  138.     def cleanup_headers(self):
  139.         if not self.headers.has_key('Content-Length'):
  140.             self.set_content_length()
  141.         
  142.  
  143.     
  144.     def start_response(self, status, headers, exc_info = None):
  145.         if exc_info:
  146.             
  147.             try:
  148.                 if self.headers_sent:
  149.                     raise exc_info[0], exc_info[1], exc_info[2]
  150.                 self.headers_sent
  151.             finally:
  152.                 exc_info = None
  153.  
  154.         elif self.headers is not None:
  155.             raise AssertionError('Headers already set!')
  156.         
  157.         self.status = status
  158.         self.headers = self.headers_class(headers)
  159.         return self.write
  160.  
  161.     
  162.     def send_preamble(self):
  163.         if self.origin_server:
  164.             if self.client_is_modern():
  165.                 self._write('HTTP/%s %s\r\n' % (self.http_version, self.status))
  166.                 if not self.headers.has_key('Date'):
  167.                     self._write('Date: %s\r\n' % format_date_time(time.time()))
  168.                 
  169.                 if self.server_software and not self.headers.has_key('Server'):
  170.                     self._write('Server: %s\r\n' % self.server_software)
  171.                 
  172.             
  173.         else:
  174.             self._write('Status: %s\r\n' % self.status)
  175.  
  176.     
  177.     def write(self, data):
  178.         if not self.status:
  179.             raise AssertionError('write() before start_response()')
  180.         self.status
  181.         self._write(data)
  182.         self._flush()
  183.  
  184.     
  185.     def sendfile(self):
  186.         return False
  187.  
  188.     
  189.     def finish_content(self):
  190.         if not self.headers_sent:
  191.             self.headers['Content-Length'] = '0'
  192.             self.send_headers()
  193.         
  194.  
  195.     
  196.     def close(self):
  197.         
  198.         try:
  199.             if hasattr(self.result, 'close'):
  200.                 self.result.close()
  201.         finally:
  202.             self.result = None
  203.             self.headers = None
  204.             self.status = None
  205.             self.environ = None
  206.             self.bytes_sent = 0
  207.             self.headers_sent = False
  208.  
  209.  
  210.     
  211.     def send_headers(self):
  212.         self.cleanup_headers()
  213.         self.headers_sent = True
  214.         if not (self.origin_server) or self.client_is_modern():
  215.             self.send_preamble()
  216.             self._write(str(self.headers))
  217.         
  218.  
  219.     
  220.     def result_is_file(self):
  221.         wrapper = self.wsgi_file_wrapper
  222.         if wrapper is not None:
  223.             pass
  224.         return isinstance(self.result, wrapper)
  225.  
  226.     
  227.     def client_is_modern(self):
  228.         return self.environ['SERVER_PROTOCOL'].upper() != 'HTTP/0.9'
  229.  
  230.     
  231.     def log_exception(self, exc_info):
  232.         
  233.         try:
  234.             print_exception = print_exception
  235.             import traceback
  236.             stderr = self.get_stderr()
  237.             print_exception(exc_info[0], exc_info[1], exc_info[2], self.traceback_limit, stderr)
  238.             stderr.flush()
  239.         finally:
  240.             exc_info = None
  241.  
  242.  
  243.     
  244.     def handle_error(self):
  245.         self.log_exception(sys.exc_info())
  246.         if not self.headers_sent:
  247.             self.result = self.error_output(self.environ, self.start_response)
  248.             self.finish_response()
  249.         
  250.  
  251.     
  252.     def error_output(self, environ, start_response):
  253.         start_response(self.error_status, self.error_headers[:], sys.exc_info())
  254.         return [
  255.             self.error_body]
  256.  
  257.     
  258.     def _write(self, data):
  259.         raise NotImplementedError
  260.  
  261.     
  262.     def _flush(self):
  263.         raise NotImplementedError
  264.  
  265.     
  266.     def get_stdin(self):
  267.         raise NotImplementedError
  268.  
  269.     
  270.     def get_stderr(self):
  271.         raise NotImplementedError
  272.  
  273.     
  274.     def add_cgi_vars(self):
  275.         raise NotImplementedError
  276.  
  277.  
  278.  
  279. class SimpleHandler(BaseHandler):
  280.     
  281.     def __init__(self, stdin, stdout, stderr, environ, multithread = True, multiprocess = False):
  282.         self.stdin = stdin
  283.         self.stdout = stdout
  284.         self.stderr = stderr
  285.         self.base_env = environ
  286.         self.wsgi_multithread = multithread
  287.         self.wsgi_multiprocess = multiprocess
  288.  
  289.     
  290.     def get_stdin(self):
  291.         return self.stdin
  292.  
  293.     
  294.     def get_stderr(self):
  295.         return self.stderr
  296.  
  297.     
  298.     def add_cgi_vars(self):
  299.         self.environ.update(self.base_env)
  300.  
  301.     
  302.     def _write(self, data):
  303.         self.stdout.write(data)
  304.         self._write = self.stdout.write
  305.  
  306.     
  307.     def _flush(self):
  308.         self.stdout.flush()
  309.         self._flush = self.stdout.flush
  310.  
  311.  
  312.  
  313. class BaseCGIHandler(SimpleHandler):
  314.     origin_server = False
  315.  
  316.  
  317. class CGIHandler(BaseCGIHandler):
  318.     wsgi_run_once = True
  319.     
  320.     def __init__(self):
  321.         BaseCGIHandler.__init__(self, sys.stdin, sys.stdout, sys.stderr, dict(os.environ.items()), multithread = False, multiprocess = True)
  322.  
  323.  
  324.