home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1490 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.4 KB  |  252 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import datetime
  5. import logging
  6. logging.Logger.manager.emittedNoHandlerWarning = 1
  7. logfmt = logging.Formatter('%(message)s')
  8. import os
  9. import rfc822
  10. import sys
  11. import cherrypy
  12. from cherrypy import _cperror
  13.  
  14. class LogManager(object):
  15.     appid = None
  16.     error_log = None
  17.     access_log = None
  18.     access_log_format = '%(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"'
  19.     
  20.     def __init__(self, appid = None, logger_root = 'cherrypy'):
  21.         self.logger_root = logger_root
  22.         self.appid = appid
  23.         if appid is None:
  24.             self.error_log = logging.getLogger('%s.error' % logger_root)
  25.             self.access_log = logging.getLogger('%s.access' % logger_root)
  26.         else:
  27.             self.error_log = logging.getLogger('%s.error.%s' % (logger_root, appid))
  28.             self.access_log = logging.getLogger('%s.access.%s' % (logger_root, appid))
  29.         self.error_log.setLevel(logging.DEBUG)
  30.         self.access_log.setLevel(logging.INFO)
  31.         cherrypy.engine.subscribe('graceful', self.reopen_files)
  32.  
  33.     
  34.     def reopen_files(self):
  35.         for log in (self.error_log, self.access_log):
  36.             for h in log.handlers:
  37.                 if isinstance(h, logging.FileHandler):
  38.                     h.acquire()
  39.                     h.stream.close()
  40.                     h.stream = open(h.baseFilename, h.mode)
  41.                     h.release()
  42.                     continue
  43.             
  44.         
  45.  
  46.     
  47.     def error(self, msg = '', context = '', severity = logging.INFO, traceback = False):
  48.         if traceback:
  49.             msg += _cperror.format_exc()
  50.         
  51.         self.error_log.log(severity, ' '.join((self.time(), context, msg)))
  52.  
  53.     
  54.     def __call__(self, *args, **kwargs):
  55.         return self.error(*args, **kwargs)
  56.  
  57.     
  58.     def access(self):
  59.         request = cherrypy.request
  60.         remote = request.remote
  61.         response = cherrypy.response
  62.         outheaders = response.headers
  63.         inheaders = request.headers
  64.         if not remote.name:
  65.             pass
  66.         if not getattr(request, 'login', None):
  67.             pass
  68.         if not outheaders.get('Content-Length', ''):
  69.             pass
  70.         atoms = {
  71.             'h': remote.ip,
  72.             'l': '-',
  73.             'u': '-',
  74.             't': self.time(),
  75.             'r': request.request_line,
  76.             's': response.status.split(' ', 1)[0],
  77.             'b': '-',
  78.             'f': inheaders.get('Referer', ''),
  79.             'a': inheaders.get('User-Agent', '') }
  80.         for k, v in atoms.items():
  81.             if isinstance(v, unicode):
  82.                 v = v.encode('utf8')
  83.             elif not isinstance(v, str):
  84.                 v = str(v)
  85.             
  86.             v = repr(v)[1:-1]
  87.             atoms[k] = v.replace('"', '\\"')
  88.         
  89.         
  90.         try:
  91.             self.access_log.log(logging.INFO, self.access_log_format % atoms)
  92.         except:
  93.             self(traceback = True)
  94.  
  95.  
  96.     
  97.     def time(self):
  98.         now = datetime.datetime.now()
  99.         month = rfc822._monthnames[now.month - 1].capitalize()
  100.         return '[%02d/%s/%04d:%02d:%02d:%02d]' % (now.day, month, now.year, now.hour, now.minute, now.second)
  101.  
  102.     
  103.     def _get_builtin_handler(self, log, key):
  104.         for h in log.handlers:
  105.             if getattr(h, '_cpbuiltin', None) == key:
  106.                 return h
  107.         
  108.  
  109.     
  110.     def _set_screen_handler(self, log, enable, stream = None):
  111.         h = self._get_builtin_handler(log, 'screen')
  112.         if enable:
  113.             if not h:
  114.                 if stream is None:
  115.                     stream = sys.stderr
  116.                 
  117.                 h = logging.StreamHandler(stream)
  118.                 h.setFormatter(logfmt)
  119.                 h._cpbuiltin = 'screen'
  120.                 log.addHandler(h)
  121.             
  122.         elif h:
  123.             log.handlers.remove(h)
  124.         
  125.  
  126.     
  127.     def _get_screen(self):
  128.         h = self._get_builtin_handler
  129.         if not h(self.error_log, 'screen'):
  130.             pass
  131.         has_h = h(self.access_log, 'screen')
  132.         return bool(has_h)
  133.  
  134.     
  135.     def _set_screen(self, newvalue):
  136.         self._set_screen_handler(self.error_log, newvalue, stream = sys.stderr)
  137.         self._set_screen_handler(self.access_log, newvalue)
  138.  
  139.     screen = property(_get_screen, _set_screen, doc = 'If True, error and access will print to stderr.')
  140.     
  141.     def _add_builtin_file_handler(self, log, fname):
  142.         h = logging.FileHandler(fname)
  143.         h.setFormatter(logfmt)
  144.         h._cpbuiltin = 'file'
  145.         log.addHandler(h)
  146.  
  147.     
  148.     def _set_file_handler(self, log, filename):
  149.         h = self._get_builtin_handler(log, 'file')
  150.         if filename:
  151.             if h:
  152.                 if h.baseFilename != os.path.abspath(filename):
  153.                     h.close()
  154.                     log.handlers.remove(h)
  155.                     self._add_builtin_file_handler(log, filename)
  156.                 
  157.             else:
  158.                 self._add_builtin_file_handler(log, filename)
  159.         elif h:
  160.             h.close()
  161.             log.handlers.remove(h)
  162.         
  163.  
  164.     
  165.     def _get_error_file(self):
  166.         h = self._get_builtin_handler(self.error_log, 'file')
  167.         if h:
  168.             return h.baseFilename
  169.         return ''
  170.  
  171.     
  172.     def _set_error_file(self, newvalue):
  173.         self._set_file_handler(self.error_log, newvalue)
  174.  
  175.     error_file = property(_get_error_file, _set_error_file, doc = 'The filename for self.error_log.')
  176.     
  177.     def _get_access_file(self):
  178.         h = self._get_builtin_handler(self.access_log, 'file')
  179.         if h:
  180.             return h.baseFilename
  181.         return ''
  182.  
  183.     
  184.     def _set_access_file(self, newvalue):
  185.         self._set_file_handler(self.access_log, newvalue)
  186.  
  187.     access_file = property(_get_access_file, _set_access_file, doc = 'The filename for self.access_log.')
  188.     
  189.     def _set_wsgi_handler(self, log, enable):
  190.         h = self._get_builtin_handler(log, 'wsgi')
  191.         if enable:
  192.             if not h:
  193.                 h = WSGIErrorHandler()
  194.                 h.setFormatter(logfmt)
  195.                 h._cpbuiltin = 'wsgi'
  196.                 log.addHandler(h)
  197.             
  198.         elif h:
  199.             log.handlers.remove(h)
  200.         
  201.  
  202.     
  203.     def _get_wsgi(self):
  204.         return bool(self._get_builtin_handler(self.error_log, 'wsgi'))
  205.  
  206.     
  207.     def _set_wsgi(self, newvalue):
  208.         self._set_wsgi_handler(self.error_log, newvalue)
  209.  
  210.     wsgi = property(_get_wsgi, _set_wsgi, doc = 'If True, error messages will be sent to wsgi.errors.')
  211.  
  212.  
  213. class WSGIErrorHandler(logging.Handler):
  214.     
  215.     def flush(self):
  216.         
  217.         try:
  218.             stream = cherrypy.request.wsgi_environ.get('wsgi.errors')
  219.         except (AttributeError, KeyError):
  220.             pass
  221.  
  222.         stream.flush()
  223.  
  224.     
  225.     def emit(self, record):
  226.         
  227.         try:
  228.             stream = cherrypy.request.wsgi_environ.get('wsgi.errors')
  229.         except (AttributeError, KeyError):
  230.             pass
  231.  
  232.         
  233.         try:
  234.             msg = self.format(record)
  235.             fs = '%s\n'
  236.             import types
  237.             if not hasattr(types, 'UnicodeType'):
  238.                 stream.write(fs % msg)
  239.             else:
  240.                 
  241.                 try:
  242.                     stream.write(fs % msg)
  243.                 except UnicodeError:
  244.                     stream.write(fs % msg.encode('UTF-8'))
  245.  
  246.             self.flush()
  247.         except:
  248.             self.handleError(record)
  249.  
  250.  
  251.  
  252.