home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_616 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.0 KB  |  319 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import logging
  6. import logging.handlers as logging
  7. import string
  8. import socket
  9. import struct
  10. import os
  11. import traceback
  12. import types
  13.  
  14. try:
  15.     import thread
  16.     import threading
  17. except ImportError:
  18.     thread = None
  19.  
  20. from SocketServer import ThreadingTCPServer, StreamRequestHandler
  21. DEFAULT_LOGGING_CONFIG_PORT = 9030
  22. if sys.platform == 'win32':
  23.     RESET_ERROR = 10054
  24. else:
  25.     RESET_ERROR = 104
  26. _listener = None
  27.  
  28. def fileConfig(fname, defaults = None, disable_existing_loggers = 1):
  29.     import ConfigParser
  30.     cp = ConfigParser.ConfigParser(defaults)
  31.     if hasattr(cp, 'readfp') and hasattr(fname, 'readline'):
  32.         cp.readfp(fname)
  33.     else:
  34.         cp.read(fname)
  35.     formatters = _create_formatters(cp)
  36.     logging._acquireLock()
  37.     
  38.     try:
  39.         logging._handlers.clear()
  40.         del logging._handlerList[:]
  41.         handlers = _install_handlers(cp, formatters)
  42.         _install_loggers(cp, handlers, disable_existing_loggers)
  43.     finally:
  44.         logging._releaseLock()
  45.  
  46.  
  47.  
  48. def _resolve(name):
  49.     name = string.split(name, '.')
  50.     used = name.pop(0)
  51.     found = __import__(used)
  52.     for n in name:
  53.         used = used + '.' + n
  54.         
  55.         try:
  56.             found = getattr(found, n)
  57.         continue
  58.         except AttributeError:
  59.             __import__(used)
  60.             found = getattr(found, n)
  61.             continue
  62.         
  63.  
  64.     
  65.     return found
  66.  
  67.  
  68. def _strip_spaces(alist):
  69.     return map((lambda x: string.strip(x)), alist)
  70.  
  71.  
  72. def _create_formatters(cp):
  73.     flist = cp.get('formatters', 'keys')
  74.     if not len(flist):
  75.         return { }
  76.     flist = string.split(flist, ',')
  77.     flist = _strip_spaces(flist)
  78.     formatters = { }
  79.     for form in flist:
  80.         sectname = 'formatter_%s' % form
  81.         opts = cp.options(sectname)
  82.         if 'format' in opts:
  83.             fs = cp.get(sectname, 'format', 1)
  84.         else:
  85.             fs = None
  86.         if 'datefmt' in opts:
  87.             dfs = cp.get(sectname, 'datefmt', 1)
  88.         else:
  89.             dfs = None
  90.         c = logging.Formatter
  91.         if 'class' in opts:
  92.             class_name = cp.get(sectname, 'class')
  93.             if class_name:
  94.                 c = _resolve(class_name)
  95.             
  96.         
  97.         f = c(fs, dfs)
  98.         formatters[form] = f
  99.     
  100.     return formatters
  101.  
  102.  
  103. def _install_handlers(cp, formatters):
  104.     hlist = cp.get('handlers', 'keys')
  105.     if not len(hlist):
  106.         return { }
  107.     hlist = string.split(hlist, ',')
  108.     hlist = _strip_spaces(hlist)
  109.     handlers = { }
  110.     fixups = []
  111.     for hand in hlist:
  112.         sectname = 'handler_%s' % hand
  113.         klass = cp.get(sectname, 'class')
  114.         opts = cp.options(sectname)
  115.         if 'formatter' in opts:
  116.             fmt = cp.get(sectname, 'formatter')
  117.         else:
  118.             fmt = ''
  119.         
  120.         try:
  121.             klass = eval(klass, vars(logging))
  122.         except (AttributeError, NameError):
  123.             klass = _resolve(klass)
  124.  
  125.         args = cp.get(sectname, 'args')
  126.         args = eval(args, vars(logging))
  127.         h = klass(*args)
  128.         if 'level' in opts:
  129.             level = cp.get(sectname, 'level')
  130.             h.setLevel(logging._levelNames[level])
  131.         
  132.         if len(fmt):
  133.             h.setFormatter(formatters[fmt])
  134.         
  135.         if issubclass(klass, logging.handlers.MemoryHandler):
  136.             if 'target' in opts:
  137.                 target = cp.get(sectname, 'target')
  138.             else:
  139.                 target = ''
  140.             if len(target):
  141.                 fixups.append((h, target))
  142.             
  143.         
  144.         handlers[hand] = h
  145.     
  146.     for h, t in fixups:
  147.         h.setTarget(handlers[t])
  148.     
  149.     return handlers
  150.  
  151.  
  152. def _install_loggers(cp, handlers, disable_existing_loggers):
  153.     llist = cp.get('loggers', 'keys')
  154.     llist = string.split(llist, ',')
  155.     llist = map((lambda x: string.strip(x)), llist)
  156.     llist.remove('root')
  157.     sectname = 'logger_root'
  158.     root = logging.root
  159.     log = root
  160.     opts = cp.options(sectname)
  161.     if 'level' in opts:
  162.         level = cp.get(sectname, 'level')
  163.         log.setLevel(logging._levelNames[level])
  164.     
  165.     for h in root.handlers[:]:
  166.         root.removeHandler(h)
  167.     
  168.     hlist = cp.get(sectname, 'handlers')
  169.     if len(hlist):
  170.         hlist = string.split(hlist, ',')
  171.         hlist = _strip_spaces(hlist)
  172.         for hand in hlist:
  173.             log.addHandler(handlers[hand])
  174.         
  175.     
  176.     existing = root.manager.loggerDict.keys()
  177.     existing.sort()
  178.     child_loggers = []
  179.     for log in llist:
  180.         sectname = 'logger_%s' % log
  181.         qn = cp.get(sectname, 'qualname')
  182.         opts = cp.options(sectname)
  183.         if 'propagate' in opts:
  184.             propagate = cp.getint(sectname, 'propagate')
  185.         else:
  186.             propagate = 1
  187.         logger = logging.getLogger(qn)
  188.         if qn in existing:
  189.             i = existing.index(qn)
  190.             prefixed = qn + '.'
  191.             pflen = len(prefixed)
  192.             num_existing = len(existing)
  193.             i = i + 1
  194.             while i < num_existing and existing[i][:pflen] == prefixed:
  195.                 child_loggers.append(existing[i])
  196.                 i = i + 1
  197.             existing.remove(qn)
  198.         
  199.         if 'level' in opts:
  200.             level = cp.get(sectname, 'level')
  201.             logger.setLevel(logging._levelNames[level])
  202.         
  203.         for h in logger.handlers[:]:
  204.             logger.removeHandler(h)
  205.         
  206.         logger.propagate = propagate
  207.         logger.disabled = 0
  208.         hlist = cp.get(sectname, 'handlers')
  209.         if len(hlist):
  210.             hlist = string.split(hlist, ',')
  211.             hlist = _strip_spaces(hlist)
  212.             for hand in hlist:
  213.                 logger.addHandler(handlers[hand])
  214.             
  215.     
  216.     for log in existing:
  217.         logger = root.manager.loggerDict[log]
  218.         if log in child_loggers:
  219.             logger.level = logging.NOTSET
  220.             logger.handlers = []
  221.             logger.propagate = 1
  222.             continue
  223.         if disable_existing_loggers:
  224.             logger.disabled = 1
  225.             continue
  226.     
  227.  
  228.  
  229. def listen(port = DEFAULT_LOGGING_CONFIG_PORT):
  230.     if not thread:
  231.         raise NotImplementedError, 'listen() needs threading to work'
  232.     thread
  233.     
  234.     class ConfigStreamHandler(StreamRequestHandler):
  235.         
  236.         def handle(self):
  237.             import tempfile
  238.             
  239.             try:
  240.                 conn = self.connection
  241.                 chunk = conn.recv(4)
  242.                 if len(chunk) == 4:
  243.                     slen = struct.unpack('>L', chunk)[0]
  244.                     chunk = self.connection.recv(slen)
  245.                     while len(chunk) < slen:
  246.                         chunk = chunk + conn.recv(slen - len(chunk))
  247.                     file = tempfile.mktemp('.ini')
  248.                     f = open(file, 'w')
  249.                     f.write(chunk)
  250.                     f.close()
  251.                     
  252.                     try:
  253.                         fileConfig(file)
  254.                     except (KeyboardInterrupt, SystemExit):
  255.                         raise 
  256.                     except:
  257.                         traceback.print_exc()
  258.  
  259.                     os.remove(file)
  260.             except socket.error:
  261.                 e = None
  262.                 if type(e.args) != types.TupleType:
  263.                     raise 
  264.                 type(e.args) != types.TupleType
  265.                 errcode = e.args[0]
  266.                 if errcode != RESET_ERROR:
  267.                     raise 
  268.                 errcode != RESET_ERROR
  269.  
  270.  
  271.  
  272.     
  273.     class ConfigSocketReceiver(ThreadingTCPServer):
  274.         allow_reuse_address = 1
  275.         
  276.         def __init__(self, host = 'localhost', port = DEFAULT_LOGGING_CONFIG_PORT, handler = None):
  277.             ThreadingTCPServer.__init__(self, (host, port), handler)
  278.             logging._acquireLock()
  279.             self.abort = 0
  280.             logging._releaseLock()
  281.             self.timeout = 1
  282.  
  283.         
  284.         def serve_until_stopped(self):
  285.             import select
  286.             abort = 0
  287.             while not abort:
  288.                 (rd, wr, ex) = select.select([
  289.                     self.socket.fileno()], [], [], self.timeout)
  290.                 if rd:
  291.                     self.handle_request()
  292.                 
  293.                 logging._acquireLock()
  294.                 abort = self.abort
  295.                 logging._releaseLock()
  296.  
  297.  
  298.     
  299.     def serve(rcvr, hdlr, port):
  300.         global _listener
  301.         server = rcvr(port = port, handler = hdlr)
  302.         logging._acquireLock()
  303.         _listener = server
  304.         logging._releaseLock()
  305.         server.serve_until_stopped()
  306.  
  307.     return threading.Thread(target = serve, args = (ConfigSocketReceiver, ConfigStreamHandler, port))
  308.  
  309.  
  310. def stopListening():
  311.     global _listener
  312.     if _listener:
  313.         logging._acquireLock()
  314.         _listener.abort = 1
  315.         _listener = None
  316.         logging._releaseLock()
  317.     
  318.  
  319.