-# Copyright 2001-2010 by Vinay Sajip. All Rights Reserved.\r
-#\r
-# Permission to use, copy, modify, and distribute this software and its\r
-# documentation for any purpose and without fee is hereby granted,\r
-# provided that the above copyright notice appear in all copies and that\r
-# both that copyright notice and this permission notice appear in\r
-# supporting documentation, and that the name of Vinay Sajip\r
-# not be used in advertising or publicity pertaining to distribution\r
-# of the software without specific, written prior permission.\r
-# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING\r
-# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL\r
-# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR\r
-# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER\r
-# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT\r
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\r
-\r
-"""\r
-Configuration functions for the logging package for Python. The core package\r
-is based on PEP 282 and comments thereto in comp.lang.python, and influenced\r
-by Apache's log4j system.\r
-\r
-Copyright (C) 2001-2010 Vinay Sajip. All Rights Reserved.\r
-\r
-To use, simply 'import logging' and log away!\r
-"""\r
-\r
-import sys, logging, logging.handlers, socket, struct, os, traceback, re\r
-import types, cStringIO\r
-\r
-try:\r
- import thread\r
- import threading\r
-except ImportError:\r
- thread = None\r
-\r
-from SocketServer import ThreadingTCPServer, StreamRequestHandler\r
-\r
-\r
-DEFAULT_LOGGING_CONFIG_PORT = 9030\r
-\r
-if sys.platform == "win32":\r
- RESET_ERROR = 10054 #WSAECONNRESET\r
-else:\r
- RESET_ERROR = 104 #ECONNRESET\r
-\r
-#\r
-# The following code implements a socket listener for on-the-fly\r
-# reconfiguration of logging.\r
-#\r
-# _listener holds the server object doing the listening\r
-_listener = None\r
-\r
-def fileConfig(fname, defaults=None, disable_existing_loggers=True):\r
- """\r
- Read the logging configuration from a ConfigParser-format file.\r
-\r
- This can be called several times from an application, allowing an end user\r
- the ability to select from various pre-canned configurations (if the\r
- developer provides a mechanism to present the choices and load the chosen\r
- configuration).\r
- """\r
- import ConfigParser\r
-\r
- cp = ConfigParser.ConfigParser(defaults)\r
- if hasattr(fname, 'readline'):\r
- cp.readfp(fname)\r
- else:\r
- cp.read(fname)\r
-\r
- formatters = _create_formatters(cp)\r
-\r
- # critical section\r
- logging._acquireLock()\r
- try:\r
- logging._handlers.clear()\r
- del logging._handlerList[:]\r
- # Handlers add themselves to logging._handlers\r
- handlers = _install_handlers(cp, formatters)\r
- _install_loggers(cp, handlers, disable_existing_loggers)\r
- finally:\r
- logging._releaseLock()\r
-\r
-\r
-def _resolve(name):\r
- """Resolve a dotted name to a global object."""\r
- name = name.split('.')\r
- used = name.pop(0)\r
- found = __import__(used)\r
- for n in name:\r
- used = used + '.' + n\r
- try:\r
- found = getattr(found, n)\r
- except AttributeError:\r
- __import__(used)\r
- found = getattr(found, n)\r
- return found\r
-\r
-def _strip_spaces(alist):\r
- return map(lambda x: x.strip(), alist)\r
-\r
-def _encoded(s):\r
- return s if isinstance(s, str) else s.encode('utf-8')\r
-\r
-def _create_formatters(cp):\r
- """Create and return formatters"""\r
- flist = cp.get("formatters", "keys")\r
- if not len(flist):\r
- return {}\r
- flist = flist.split(",")\r
- flist = _strip_spaces(flist)\r
- formatters = {}\r
- for form in flist:\r
- sectname = "formatter_%s" % form\r
- opts = cp.options(sectname)\r
- if "format" in opts:\r
- fs = cp.get(sectname, "format", 1)\r
- else:\r
- fs = None\r
- if "datefmt" in opts:\r
- dfs = cp.get(sectname, "datefmt", 1)\r
- else:\r
- dfs = None\r
- c = logging.Formatter\r
- if "class" in opts:\r
- class_name = cp.get(sectname, "class")\r
- if class_name:\r
- c = _resolve(class_name)\r
- f = c(fs, dfs)\r
- formatters[form] = f\r
- return formatters\r
-\r
-\r
-def _install_handlers(cp, formatters):\r
- """Install and return handlers"""\r
- hlist = cp.get("handlers", "keys")\r
- if not len(hlist):\r
- return {}\r
- hlist = hlist.split(",")\r
- hlist = _strip_spaces(hlist)\r
- handlers = {}\r
- fixups = [] #for inter-handler references\r
- for hand in hlist:\r
- sectname = "handler_%s" % hand\r
- klass = cp.get(sectname, "class")\r
- opts = cp.options(sectname)\r
- if "formatter" in opts:\r
- fmt = cp.get(sectname, "formatter")\r
- else:\r
- fmt = ""\r
- try:\r
- klass = eval(klass, vars(logging))\r
- except (AttributeError, NameError):\r
- klass = _resolve(klass)\r
- args = cp.get(sectname, "args")\r
- args = eval(args, vars(logging))\r
- h = klass(*args)\r
- if "level" in opts:\r
- level = cp.get(sectname, "level")\r
- h.setLevel(logging._levelNames[level])\r
- if len(fmt):\r
- h.setFormatter(formatters[fmt])\r
- if issubclass(klass, logging.handlers.MemoryHandler):\r
- if "target" in opts:\r
- target = cp.get(sectname,"target")\r
- else:\r
- target = ""\r
- if len(target): #the target handler may not be loaded yet, so keep for later...\r
- fixups.append((h, target))\r
- handlers[hand] = h\r
- #now all handlers are loaded, fixup inter-handler references...\r
- for h, t in fixups:\r
- h.setTarget(handlers[t])\r
- return handlers\r
-\r
-\r
-def _install_loggers(cp, handlers, disable_existing_loggers):\r
- """Create and install loggers"""\r
-\r
- # configure the root first\r
- llist = cp.get("loggers", "keys")\r
- llist = llist.split(",")\r
- llist = list(map(lambda x: x.strip(), llist))\r
- llist.remove("root")\r
- sectname = "logger_root"\r
- root = logging.root\r
- log = root\r
- opts = cp.options(sectname)\r
- if "level" in opts:\r
- level = cp.get(sectname, "level")\r
- log.setLevel(logging._levelNames[level])\r
- for h in root.handlers[:]:\r
- root.removeHandler(h)\r
- hlist = cp.get(sectname, "handlers")\r
- if len(hlist):\r
- hlist = hlist.split(",")\r
- hlist = _strip_spaces(hlist)\r
- for hand in hlist:\r
- log.addHandler(handlers[hand])\r
-\r
- #and now the others...\r
- #we don't want to lose the existing loggers,\r
- #since other threads may have pointers to them.\r
- #existing is set to contain all existing loggers,\r
- #and as we go through the new configuration we\r
- #remove any which are configured. At the end,\r
- #what's left in existing is the set of loggers\r
- #which were in the previous configuration but\r
- #which are not in the new configuration.\r
- existing = list(root.manager.loggerDict.keys())\r
- #The list needs to be sorted so that we can\r
- #avoid disabling child loggers of explicitly\r
- #named loggers. With a sorted list it is easier\r
- #to find the child loggers.\r
- existing.sort(key=_encoded)\r
- #We'll keep the list of existing loggers\r
- #which are children of named loggers here...\r
- child_loggers = []\r
- #now set up the new ones...\r
- for log in llist:\r
- sectname = "logger_%s" % log\r
- qn = cp.get(sectname, "qualname")\r
- opts = cp.options(sectname)\r
- if "propagate" in opts:\r
- propagate = cp.getint(sectname, "propagate")\r
- else:\r
- propagate = 1\r
- logger = logging.getLogger(qn)\r
- if qn in existing:\r
- i = existing.index(qn) + 1 # start with the entry after qn\r
- prefixed = qn + "."\r
- pflen = len(prefixed)\r
- num_existing = len(existing)\r
- while i < num_existing:\r
- if existing[i][:pflen] == prefixed:\r
- child_loggers.append(existing[i])\r
- i += 1\r
- existing.remove(qn)\r
- if "level" in opts:\r
- level = cp.get(sectname, "level")\r
- logger.setLevel(logging._levelNames[level])\r
- for h in logger.handlers[:]:\r
- logger.removeHandler(h)\r
- logger.propagate = propagate\r
- logger.disabled = 0\r
- hlist = cp.get(sectname, "handlers")\r
- if len(hlist):\r
- hlist = hlist.split(",")\r
- hlist = _strip_spaces(hlist)\r
- for hand in hlist:\r
- logger.addHandler(handlers[hand])\r
-\r
- #Disable any old loggers. There's no point deleting\r
- #them as other threads may continue to hold references\r
- #and by disabling them, you stop them doing any logging.\r
- #However, don't disable children of named loggers, as that's\r
- #probably not what was intended by the user.\r
- for log in existing:\r
- logger = root.manager.loggerDict[log]\r
- if log in child_loggers:\r
- logger.level = logging.NOTSET\r
- logger.handlers = []\r
- logger.propagate = 1\r
- elif disable_existing_loggers:\r
- logger.disabled = 1\r
-\r
-\r
-\r
-IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)\r
-\r
-\r
-def valid_ident(s):\r
- m = IDENTIFIER.match(s)\r
- if not m:\r
- raise ValueError('Not a valid Python identifier: %r' % s)\r
- return True\r
-\r
-\r
-# The ConvertingXXX classes are wrappers around standard Python containers,\r
-# and they serve to convert any suitable values in the container. The\r
-# conversion converts base dicts, lists and tuples to their wrapped\r
-# equivalents, whereas strings which match a conversion format are converted\r
-# appropriately.\r
-#\r
-# Each wrapper should have a configurator attribute holding the actual\r
-# configurator to use for conversion.\r
-\r
-class ConvertingDict(dict):\r
- """A converting dictionary wrapper."""\r
-\r
- def __getitem__(self, key):\r
- value = dict.__getitem__(self, key)\r
- result = self.configurator.convert(value)\r
- #If the converted value is different, save for next time\r
- if value is not result:\r
- self[key] = result\r
- if type(result) in (ConvertingDict, ConvertingList,\r
- ConvertingTuple):\r
- result.parent = self\r
- result.key = key\r
- return result\r
-\r
- def get(self, key, default=None):\r
- value = dict.get(self, key, default)\r
- result = self.configurator.convert(value)\r
- #If the converted value is different, save for next time\r
- if value is not result:\r
- self[key] = result\r
- if type(result) in (ConvertingDict, ConvertingList,\r
- ConvertingTuple):\r
- result.parent = self\r
- result.key = key\r
- return result\r
-\r
- def pop(self, key, default=None):\r
- value = dict.pop(self, key, default)\r
- result = self.configurator.convert(value)\r
- if value is not result:\r
- if type(result) in (ConvertingDict, ConvertingList,\r
- ConvertingTuple):\r
- result.parent = self\r
- result.key = key\r
- return result\r
-\r
-class ConvertingList(list):\r
- """A converting list wrapper."""\r
- def __getitem__(self, key):\r
- value = list.__getitem__(self, key)\r
- result = self.configurator.convert(value)\r
- #If the converted value is different, save for next time\r
- if value is not result:\r
- self[key] = result\r
- if type(result) in (ConvertingDict, ConvertingList,\r
- ConvertingTuple):\r
- result.parent = self\r
- result.key = key\r
- return result\r
-\r
- def pop(self, idx=-1):\r
- value = list.pop(self, idx)\r
- result = self.configurator.convert(value)\r
- if value is not result:\r
- if type(result) in (ConvertingDict, ConvertingList,\r
- ConvertingTuple):\r
- result.parent = self\r
- return result\r
-\r
-class ConvertingTuple(tuple):\r
- """A converting tuple wrapper."""\r
- def __getitem__(self, key):\r
- value = tuple.__getitem__(self, key)\r
- result = self.configurator.convert(value)\r
- if value is not result:\r
- if type(result) in (ConvertingDict, ConvertingList,\r
- ConvertingTuple):\r
- result.parent = self\r
- result.key = key\r
- return result\r
-\r
-class BaseConfigurator(object):\r
- """\r
- The configurator base class which defines some useful defaults.\r
- """\r
-\r
- CONVERT_PATTERN = re.compile(r'^(?P<prefix>[a-z]+)://(?P<suffix>.*)$')\r
-\r
- WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')\r
- DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')\r
- INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')\r
- DIGIT_PATTERN = re.compile(r'^\d+$')\r
-\r
- value_converters = {\r
- 'ext' : 'ext_convert',\r
- 'cfg' : 'cfg_convert',\r
- }\r
-\r
- # We might want to use a different one, e.g. importlib\r
- importer = __import__\r
-\r
- def __init__(self, config):\r
- self.config = ConvertingDict(config)\r
- self.config.configurator = self\r
-\r
- def resolve(self, s):\r
- """\r
- Resolve strings to objects using standard import and attribute\r
- syntax.\r
- """\r
- name = s.split('.')\r
- used = name.pop(0)\r
- try:\r
- found = self.importer(used)\r
- for frag in name:\r
- used += '.' + frag\r
- try:\r
- found = getattr(found, frag)\r
- except AttributeError:\r
- self.importer(used)\r
- found = getattr(found, frag)\r
- return found\r
- except ImportError:\r
- e, tb = sys.exc_info()[1:]\r
- v = ValueError('Cannot resolve %r: %s' % (s, e))\r
- v.__cause__, v.__traceback__ = e, tb\r
- raise v\r
-\r
- def ext_convert(self, value):\r
- """Default converter for the ext:// protocol."""\r
- return self.resolve(value)\r
-\r
- def cfg_convert(self, value):\r
- """Default converter for the cfg:// protocol."""\r
- rest = value\r
- m = self.WORD_PATTERN.match(rest)\r
- if m is None:\r
- raise ValueError("Unable to convert %r" % value)\r
- else:\r
- rest = rest[m.end():]\r
- d = self.config[m.groups()[0]]\r
- #print d, rest\r
- while rest:\r
- m = self.DOT_PATTERN.match(rest)\r
- if m:\r
- d = d[m.groups()[0]]\r
- else:\r
- m = self.INDEX_PATTERN.match(rest)\r
- if m:\r
- idx = m.groups()[0]\r
- if not self.DIGIT_PATTERN.match(idx):\r
- d = d[idx]\r
- else:\r
- try:\r
- n = int(idx) # try as number first (most likely)\r
- d = d[n]\r
- except TypeError:\r
- d = d[idx]\r
- if m:\r
- rest = rest[m.end():]\r
- else:\r
- raise ValueError('Unable to convert '\r
- '%r at %r' % (value, rest))\r
- #rest should be empty\r
- return d\r
-\r
- def convert(self, value):\r
- """\r
- Convert values to an appropriate type. dicts, lists and tuples are\r
- replaced by their converting alternatives. Strings are checked to\r
- see if they have a conversion format and are converted if they do.\r
- """\r
- if not isinstance(value, ConvertingDict) and isinstance(value, dict):\r
- value = ConvertingDict(value)\r
- value.configurator = self\r
- elif not isinstance(value, ConvertingList) and isinstance(value, list):\r
- value = ConvertingList(value)\r
- value.configurator = self\r
- elif not isinstance(value, ConvertingTuple) and\\r
- isinstance(value, tuple):\r
- value = ConvertingTuple(value)\r
- value.configurator = self\r
- elif isinstance(value, basestring): # str for py3k\r
- m = self.CONVERT_PATTERN.match(value)\r
- if m:\r
- d = m.groupdict()\r
- prefix = d['prefix']\r
- converter = self.value_converters.get(prefix, None)\r
- if converter:\r
- suffix = d['suffix']\r
- converter = getattr(self, converter)\r
- value = converter(suffix)\r
- return value\r
-\r
- def configure_custom(self, config):\r
- """Configure an object with a user-supplied factory."""\r
- c = config.pop('()')\r
- if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType:\r
- c = self.resolve(c)\r
- props = config.pop('.', None)\r
- # Check for valid identifiers\r
- kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])\r
- result = c(**kwargs)\r
- if props:\r
- for name, value in props.items():\r
- setattr(result, name, value)\r
- return result\r
-\r
- def as_tuple(self, value):\r
- """Utility function which converts lists to tuples."""\r
- if isinstance(value, list):\r
- value = tuple(value)\r
- return value\r
-\r
-class DictConfigurator(BaseConfigurator):\r
- """\r
- Configure logging using a dictionary-like object to describe the\r
- configuration.\r
- """\r
-\r
- def configure(self):\r
- """Do the configuration."""\r
-\r
- config = self.config\r
- if 'version' not in config:\r
- raise ValueError("dictionary doesn't specify a version")\r
- if config['version'] != 1:\r
- raise ValueError("Unsupported version: %s" % config['version'])\r
- incremental = config.pop('incremental', False)\r
- EMPTY_DICT = {}\r
- logging._acquireLock()\r
- try:\r
- if incremental:\r
- handlers = config.get('handlers', EMPTY_DICT)\r
- for name in handlers:\r
- if name not in logging._handlers:\r
- raise ValueError('No handler found with '\r
- 'name %r' % name)\r
- else:\r
- try:\r
- handler = logging._handlers[name]\r
- handler_config = handlers[name]\r
- level = handler_config.get('level', None)\r
- if level:\r
- handler.setLevel(logging._checkLevel(level))\r
- except StandardError, e:\r
- raise ValueError('Unable to configure handler '\r
- '%r: %s' % (name, e))\r
- loggers = config.get('loggers', EMPTY_DICT)\r
- for name in loggers:\r
- try:\r
- self.configure_logger(name, loggers[name], True)\r
- except StandardError, e:\r
- raise ValueError('Unable to configure logger '\r
- '%r: %s' % (name, e))\r
- root = config.get('root', None)\r
- if root:\r
- try:\r
- self.configure_root(root, True)\r
- except StandardError, e:\r
- raise ValueError('Unable to configure root '\r
- 'logger: %s' % e)\r
- else:\r
- disable_existing = config.pop('disable_existing_loggers', True)\r
-\r
- logging._handlers.clear()\r
- del logging._handlerList[:]\r
-\r
- # Do formatters first - they don't refer to anything else\r
- formatters = config.get('formatters', EMPTY_DICT)\r
- for name in formatters:\r
- try:\r
- formatters[name] = self.configure_formatter(\r
- formatters[name])\r
- except StandardError, e:\r
- raise ValueError('Unable to configure '\r
- 'formatter %r: %s' % (name, e))\r
- # Next, do filters - they don't refer to anything else, either\r
- filters = config.get('filters', EMPTY_DICT)\r
- for name in filters:\r
- try:\r
- filters[name] = self.configure_filter(filters[name])\r
- except StandardError, e:\r
- raise ValueError('Unable to configure '\r
- 'filter %r: %s' % (name, e))\r
-\r
- # Next, do handlers - they refer to formatters and filters\r
- # As handlers can refer to other handlers, sort the keys\r
- # to allow a deterministic order of configuration\r
- handlers = config.get('handlers', EMPTY_DICT)\r
- for name in sorted(handlers):\r
- try:\r
- handler = self.configure_handler(handlers[name])\r
- handler.name = name\r
- handlers[name] = handler\r
- except StandardError, e:\r
- raise ValueError('Unable to configure handler '\r
- '%r: %s' % (name, e))\r
- # Next, do loggers - they refer to handlers and filters\r
-\r
- #we don't want to lose the existing loggers,\r
- #since other threads may have pointers to them.\r
- #existing is set to contain all existing loggers,\r
- #and as we go through the new configuration we\r
- #remove any which are configured. At the end,\r
- #what's left in existing is the set of loggers\r
- #which were in the previous configuration but\r
- #which are not in the new configuration.\r
- root = logging.root\r
- existing = root.manager.loggerDict.keys()\r
- #The list needs to be sorted so that we can\r
- #avoid disabling child loggers of explicitly\r
- #named loggers. With a sorted list it is easier\r
- #to find the child loggers.\r
- existing.sort(key=_encoded)\r
- #We'll keep the list of existing loggers\r
- #which are children of named loggers here...\r
- child_loggers = []\r
- #now set up the new ones...\r
- loggers = config.get('loggers', EMPTY_DICT)\r
- for name in loggers:\r
- if name in existing:\r
- i = existing.index(name)\r
- prefixed = name + "."\r
- pflen = len(prefixed)\r
- num_existing = len(existing)\r
- i = i + 1 # look at the entry after name\r
- while (i < num_existing) and\\r
- (existing[i][:pflen] == prefixed):\r
- child_loggers.append(existing[i])\r
- i = i + 1\r
- existing.remove(name)\r
- try:\r
- self.configure_logger(name, loggers[name])\r
- except StandardError, e:\r
- raise ValueError('Unable to configure logger '\r
- '%r: %s' % (name, e))\r
-\r
- #Disable any old loggers. There's no point deleting\r
- #them as other threads may continue to hold references\r
- #and by disabling them, you stop them doing any logging.\r
- #However, don't disable children of named loggers, as that's\r
- #probably not what was intended by the user.\r
- for log in existing:\r
- logger = root.manager.loggerDict[log]\r
- if log in child_loggers:\r
- logger.level = logging.NOTSET\r
- logger.handlers = []\r
- logger.propagate = True\r
- elif disable_existing:\r
- logger.disabled = True\r
-\r
- # And finally, do the root logger\r
- root = config.get('root', None)\r
- if root:\r
- try:\r
- self.configure_root(root)\r
- except StandardError, e:\r
- raise ValueError('Unable to configure root '\r
- 'logger: %s' % e)\r
- finally:\r
- logging._releaseLock()\r
-\r
- def configure_formatter(self, config):\r
- """Configure a formatter from a dictionary."""\r
- if '()' in config:\r
- factory = config['()'] # for use in exception handler\r
- try:\r
- result = self.configure_custom(config)\r
- except TypeError, te:\r
- if "'format'" not in str(te):\r
- raise\r
- #Name of parameter changed from fmt to format.\r
- #Retry with old name.\r
- #This is so that code can be used with older Python versions\r
- #(e.g. by Django)\r
- config['fmt'] = config.pop('format')\r
- config['()'] = factory\r
- result = self.configure_custom(config)\r
- else:\r
- fmt = config.get('format', None)\r
- dfmt = config.get('datefmt', None)\r
- result = logging.Formatter(fmt, dfmt)\r
- return result\r
-\r
- def configure_filter(self, config):\r
- """Configure a filter from a dictionary."""\r
- if '()' in config:\r
- result = self.configure_custom(config)\r
- else:\r
- name = config.get('name', '')\r
- result = logging.Filter(name)\r
- return result\r
-\r
- def add_filters(self, filterer, filters):\r
- """Add filters to a filterer from a list of names."""\r
- for f in filters:\r
- try:\r
- filterer.addFilter(self.config['filters'][f])\r
- except StandardError, e:\r
- raise ValueError('Unable to add filter %r: %s' % (f, e))\r
-\r
- def configure_handler(self, config):\r
- """Configure a handler from a dictionary."""\r
- formatter = config.pop('formatter', None)\r
- if formatter:\r
- try:\r
- formatter = self.config['formatters'][formatter]\r
- except StandardError, e:\r
- raise ValueError('Unable to set formatter '\r
- '%r: %s' % (formatter, e))\r
- level = config.pop('level', None)\r
- filters = config.pop('filters', None)\r
- if '()' in config:\r
- c = config.pop('()')\r
- if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType:\r
- c = self.resolve(c)\r
- factory = c\r
- else:\r
- klass = self.resolve(config.pop('class'))\r
- #Special case for handler which refers to another handler\r
- if issubclass(klass, logging.handlers.MemoryHandler) and\\r
- 'target' in config:\r
- try:\r
- config['target'] = self.config['handlers'][config['target']]\r
- except StandardError, e:\r
- raise ValueError('Unable to set target handler '\r
- '%r: %s' % (config['target'], e))\r
- elif issubclass(klass, logging.handlers.SMTPHandler) and\\r
- 'mailhost' in config:\r
- config['mailhost'] = self.as_tuple(config['mailhost'])\r
- elif issubclass(klass, logging.handlers.SysLogHandler) and\\r
- 'address' in config:\r
- config['address'] = self.as_tuple(config['address'])\r
- factory = klass\r
- kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])\r
- try:\r
- result = factory(**kwargs)\r
- except TypeError, te:\r
- if "'stream'" not in str(te):\r
- raise\r
- #The argument name changed from strm to stream\r
- #Retry with old name.\r
- #This is so that code can be used with older Python versions\r
- #(e.g. by Django)\r
- kwargs['strm'] = kwargs.pop('stream')\r
- result = factory(**kwargs)\r
- if formatter:\r
- result.setFormatter(formatter)\r
- if level is not None:\r
- result.setLevel(logging._checkLevel(level))\r
- if filters:\r
- self.add_filters(result, filters)\r
- return result\r
-\r
- def add_handlers(self, logger, handlers):\r
- """Add handlers to a logger from a list of names."""\r
- for h in handlers:\r
- try:\r
- logger.addHandler(self.config['handlers'][h])\r
- except StandardError, e:\r
- raise ValueError('Unable to add handler %r: %s' % (h, e))\r
-\r
- def common_logger_config(self, logger, config, incremental=False):\r
- """\r
- Perform configuration which is common to root and non-root loggers.\r
- """\r
- level = config.get('level', None)\r
- if level is not None:\r
- logger.setLevel(logging._checkLevel(level))\r
- if not incremental:\r
- #Remove any existing handlers\r
- for h in logger.handlers[:]:\r
- logger.removeHandler(h)\r
- handlers = config.get('handlers', None)\r
- if handlers:\r
- self.add_handlers(logger, handlers)\r
- filters = config.get('filters', None)\r
- if filters:\r
- self.add_filters(logger, filters)\r
-\r
- def configure_logger(self, name, config, incremental=False):\r
- """Configure a non-root logger from a dictionary."""\r
- logger = logging.getLogger(name)\r
- self.common_logger_config(logger, config, incremental)\r
- propagate = config.get('propagate', None)\r
- if propagate is not None:\r
- logger.propagate = propagate\r
-\r
- def configure_root(self, config, incremental=False):\r
- """Configure a root logger from a dictionary."""\r
- root = logging.getLogger()\r
- self.common_logger_config(root, config, incremental)\r
-\r
-dictConfigClass = DictConfigurator\r
-\r
-def dictConfig(config):\r
- """Configure logging using a dictionary."""\r
- dictConfigClass(config).configure()\r
-\r
-\r
-def listen(port=DEFAULT_LOGGING_CONFIG_PORT):\r
- """\r
- Start up a socket server on the specified port, and listen for new\r
- configurations.\r
-\r
- These will be sent as a file suitable for processing by fileConfig().\r
- Returns a Thread object on which you can call start() to start the server,\r
- and which you can join() when appropriate. To stop the server, call\r
- stopListening().\r
- """\r
- if not thread:\r
- raise NotImplementedError("listen() needs threading to work")\r
-\r
- class ConfigStreamHandler(StreamRequestHandler):\r
- """\r
- Handler for a logging configuration request.\r
-\r
- It expects a completely new logging configuration and uses fileConfig\r
- to install it.\r
- """\r
- def handle(self):\r
- """\r
- Handle a request.\r
-\r
- Each request is expected to be a 4-byte length, packed using\r
- struct.pack(">L", n), followed by the config file.\r
- Uses fileConfig() to do the grunt work.\r
- """\r
- import tempfile\r
- try:\r
- conn = self.connection\r
- chunk = conn.recv(4)\r
- if len(chunk) == 4:\r
- slen = struct.unpack(">L", chunk)[0]\r
- chunk = self.connection.recv(slen)\r
- while len(chunk) < slen:\r
- chunk = chunk + conn.recv(slen - len(chunk))\r
- try:\r
- import json\r
- d =json.loads(chunk)\r
- assert isinstance(d, dict)\r
- dictConfig(d)\r
- except:\r
- #Apply new configuration.\r
-\r
- file = cStringIO.StringIO(chunk)\r
- try:\r
- fileConfig(file)\r
- except (KeyboardInterrupt, SystemExit):\r
- raise\r
- except:\r
- traceback.print_exc()\r
- if self.server.ready:\r
- self.server.ready.set()\r
- except socket.error, e:\r
- if not isinstance(e.args, tuple):\r
- raise\r
- else:\r
- errcode = e.args[0]\r
- if errcode != RESET_ERROR:\r
- raise\r
-\r
- class ConfigSocketReceiver(ThreadingTCPServer):\r
- """\r
- A simple TCP socket-based logging config receiver.\r
- """\r
-\r
- allow_reuse_address = 1\r
-\r
- def __init__(self, host='localhost', port=DEFAULT_LOGGING_CONFIG_PORT,\r
- handler=None, ready=None):\r
- ThreadingTCPServer.__init__(self, (host, port), handler)\r
- logging._acquireLock()\r
- self.abort = 0\r
- logging._releaseLock()\r
- self.timeout = 1\r
- self.ready = ready\r
-\r
- def serve_until_stopped(self):\r
- import select\r
- abort = 0\r
- while not abort:\r
- rd, wr, ex = select.select([self.socket.fileno()],\r
- [], [],\r
- self.timeout)\r
- if rd:\r
- self.handle_request()\r
- logging._acquireLock()\r
- abort = self.abort\r
- logging._releaseLock()\r
- self.socket.close()\r
-\r
- class Server(threading.Thread):\r
-\r
- def __init__(self, rcvr, hdlr, port):\r
- super(Server, self).__init__()\r
- self.rcvr = rcvr\r
- self.hdlr = hdlr\r
- self.port = port\r
- self.ready = threading.Event()\r
-\r
- def run(self):\r
- server = self.rcvr(port=self.port, handler=self.hdlr,\r
- ready=self.ready)\r
- if self.port == 0:\r
- self.port = server.server_address[1]\r
- self.ready.set()\r
- global _listener\r
- logging._acquireLock()\r
- _listener = server\r
- logging._releaseLock()\r
- server.serve_until_stopped()\r
-\r
- return Server(ConfigSocketReceiver, ConfigStreamHandler, port)\r
-\r
-def stopListening():\r
- """\r
- Stop the listening server which was created with a call to listen().\r
- """\r
- global _listener\r
- logging._acquireLock()\r
- try:\r
- if _listener:\r
- _listener.abort = 1\r
- _listener = None\r
- finally:\r
- logging._releaseLock()\r
projects / mirror_edk2.git / blobdiff