config.py

# Copyright 2001-2019 by Vinay Sajip. All Rights Reserved.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose and without fee is hereby granted,
# provided that the above copyright notice appear in all copies and that
# both that copyright notice and this permission notice appear in
# supporting documentation, and that the name of Vinay Sajip
# not be used in advertising or publicity pertaining to distribution
# of the software without specific, written prior permission.
# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

"""
Configuration functions for the logging package for Python. The core package
is based on PEP 282 and comments thereto in comp.lang.python, and influenced
by Apache's log4j system.

Copyright (C) 2001-2019 Vinay Sajip. All Rights Reserved.

To use, simply 'import logging' and log away!
"""

importerrno
importio
importlogging
importlogging.handlers
importre
importstruct
importsys
importthreading
importtraceback

fromsocketserverimportThreadingTCPServer, StreamRequestHandler


DEFAULT_LOGGING_CONFIG_PORT=9030

RESET_ERROR=errno.ECONNRESET

#
# The following code implements a socket listener for on-the-fly
# reconfiguration of logging.
#
# _listener holds the server object doing the listening
_listener=None

deffileConfig(fname, defaults=None, disable_existing_loggers=True):
"""
 Read the logging configuration from a ConfigParser-format file.

 This can be called several times from an application, allowing an end user
 the ability to select from various pre-canned configurations (if the
 developer provides a mechanism to present the choices and load the chosen
 configuration).
 """
importconfigparser

ifisinstance(fname, configparser.RawConfigParser):
cp=fname
else:
cp=configparser.ConfigParser(defaults)
ifhasattr(fname, 'readline'):
cp.read_file(fname)
else:
cp.read(fname)

formatters=_create_formatters(cp)

# critical section
logging._acquireLock()
try:
_clearExistingHandlers()

# Handlers add themselves to logging._handlers
handlers=_install_handlers(cp, formatters)
_install_loggers(cp, handlers, disable_existing_loggers)
finally:
logging._releaseLock()


def_resolve(name):
"""Resolve a dotted name to a global object."""
name=name.split('.')
used=name.pop(0)
found=__import__(used)
forninname:
used=used+'.'+n
try:
found=getattr(found, n)
exceptAttributeError:
__import__(used)
found=getattr(found, n)
returnfound

def_strip_spaces(alist):
returnmap(str.strip, alist)

def_create_formatters(cp):
"""Create and return formatters"""
flist=cp["formatters"]["keys"]
ifnotlen(flist):
return {}
flist=flist.split(",")
flist=_strip_spaces(flist)
formatters= {}
forforminflist:
sectname="formatter_%s"%form
fs=cp.get(sectname, "format", raw=True, fallback=None)
dfs=cp.get(sectname, "datefmt", raw=True, fallback=None)
stl=cp.get(sectname, "style", raw=True, fallback='%')
c=logging.Formatter
class_name=cp[sectname].get("class")
ifclass_name:
c=_resolve(class_name)
f=c(fs, dfs, stl)
formatters[form] =f
returnformatters


def_install_handlers(cp, formatters):
"""Install and return handlers"""
hlist=cp["handlers"]["keys"]
ifnotlen(hlist):
return {}
hlist=hlist.split(",")
hlist=_strip_spaces(hlist)
handlers= {}
fixups= [] #for inter-handler references
forhandinhlist:
section=cp["handler_%s"%hand]
klass=section["class"]
fmt=section.get("formatter", "")
try:
klass=eval(klass, vars(logging))
except (AttributeError, NameError):
klass=_resolve(klass)
args=section.get("args", '()')
args=eval(args, vars(logging))
kwargs=section.get("kwargs", '{}')
kwargs=eval(kwargs, vars(logging))
h=klass(*args, **kwargs)
if"level"insection:
level=section["level"]
h.setLevel(level)
iflen(fmt):
h.setFormatter(formatters[fmt])
ifissubclass(klass, logging.handlers.MemoryHandler):
target=section.get("target", "")
iflen(target): #the target handler may not be loaded yet, so keep for later...
fixups.append((h, target))
handlers[hand] =h
#now all handlers are loaded, fixup inter-handler references...
forh, tinfixups:
h.setTarget(handlers[t])
returnhandlers

def_handle_existing_loggers(existing, child_loggers, disable_existing):
"""
 When (re)configuring logging, handle loggers which were in the previous
 configuration but are not in the new configuration. There's no point
 deleting them as other threads may continue to hold references to them;
 and by disabling them, you stop them doing any logging.

 However, don't disable children of named loggers, as that's probably not
 what was intended by the user. Also, allow existing loggers to NOT be
 disabled if disable_existing is false.
 """
root=logging.root
forloginexisting:
logger=root.manager.loggerDict[log]
ifloginchild_loggers:
ifnotisinstance(logger, logging.PlaceHolder):
logger.setLevel(logging.NOTSET)
logger.handlers= []
logger.propagate=True
else:
logger.disabled=disable_existing

def_install_loggers(cp, handlers, disable_existing):
"""Create and install loggers"""

# configure the root first
llist=cp["loggers"]["keys"]
llist=llist.split(",")
llist=list(_strip_spaces(llist))
llist.remove("root")
section=cp["logger_root"]
root=logging.root
log=root
if"level"insection:
level=section["level"]
log.setLevel(level)
forhinroot.handlers[:]:
root.removeHandler(h)
hlist=section["handlers"]
iflen(hlist):
hlist=hlist.split(",")
hlist=_strip_spaces(hlist)
forhandinhlist:
log.addHandler(handlers[hand])

#and now the others...
#we don't want to lose the existing loggers,
#since other threads may have pointers to them.
#existing is set to contain all existing loggers,
#and as we go through the new configuration we
#remove any which are configured. At the end,
#what's left in existing is the set of loggers
#which were in the previous configuration but
#which are not in the new configuration.
existing=list(root.manager.loggerDict.keys())
#The list needs to be sorted so that we can
#avoid disabling child loggers of explicitly
#named loggers. With a sorted list it is easier
#to find the child loggers.
existing.sort()
#We'll keep the list of existing loggers
#which are children of named loggers here...
child_loggers= []
#now set up the new ones...
forloginllist:
section=cp["logger_%s"%log]
qn=section["qualname"]
propagate=section.getint("propagate", fallback=1)
logger=logging.getLogger(qn)
ifqninexisting:
i=existing.index(qn) +1# start with the entry after qn
prefixed=qn+"."
pflen=len(prefixed)
num_existing=len(existing)
whilei<num_existing:
ifexisting[i][:pflen] ==prefixed:
child_loggers.append(existing[i])
i+=1
existing.remove(qn)
if"level"insection:
level=section["level"]
logger.setLevel(level)
forhinlogger.handlers[:]:
logger.removeHandler(h)
logger.propagate=propagate
logger.disabled=0
hlist=section["handlers"]
iflen(hlist):
hlist=hlist.split(",")
hlist=_strip_spaces(hlist)
forhandinhlist:
logger.addHandler(handlers[hand])

#Disable any old loggers. There's no point deleting
#them as other threads may continue to hold references
#and by disabling them, you stop them doing any logging.
#However, don't disable children of named loggers, as that's
#probably not what was intended by the user.
#for log in existing:
# logger = root.manager.loggerDict[log]
# if log in child_loggers:
# logger.level = logging.NOTSET
# logger.handlers = []
# logger.propagate = 1
# elif disable_existing_loggers:
# logger.disabled = 1
_handle_existing_loggers(existing, child_loggers, disable_existing)


def_clearExistingHandlers():
"""Clear and close existing handlers"""
logging._handlers.clear()
logging.shutdown(logging._handlerList[:])
dellogging._handlerList[:]


IDENTIFIER=re.compile('^[a-z_][a-z0-9_]*$', re.I)


defvalid_ident(s):
m=IDENTIFIER.match(s)
ifnotm:
raiseValueError('Not a valid Python identifier: %r'%s)
returnTrue


classConvertingMixin(object):
"""For ConvertingXXX's, this mixin class provides common functions"""

defconvert_with_key(self, key, value, replace=True):
result=self.configurator.convert(value)
#If the converted value is different, save for next time
ifvalueisnotresult:
ifreplace:
self[key] =result
iftype(result) in (ConvertingDict, ConvertingList,
ConvertingTuple):
result.parent=self
result.key=key
returnresult

defconvert(self, value):
result=self.configurator.convert(value)
ifvalueisnotresult:
iftype(result) in (ConvertingDict, ConvertingList,
ConvertingTuple):
result.parent=self
returnresult


# The ConvertingXXX classes are wrappers around standard Python containers,
# and they serve to convert any suitable values in the container. The
# conversion converts base dicts, lists and tuples to their wrapped
# equivalents, whereas strings which match a conversion format are converted
# appropriately.
#
# Each wrapper should have a configurator attribute holding the actual
# configurator to use for conversion.

classConvertingDict(dict, ConvertingMixin):
"""A converting dictionary wrapper."""

def__getitem__(self, key):
value=dict.__getitem__(self, key)
returnself.convert_with_key(key, value)

defget(self, key, default=None):
value=dict.get(self, key, default)
returnself.convert_with_key(key, value)

defpop(self, key, default=None):
value=dict.pop(self, key, default)
returnself.convert_with_key(key, value, replace=False)

classConvertingList(list, ConvertingMixin):
"""A converting list wrapper."""
def__getitem__(self, key):
value=list.__getitem__(self, key)
returnself.convert_with_key(key, value)

defpop(self, idx=-1):
value=list.pop(self, idx)
returnself.convert(value)

classConvertingTuple(tuple, ConvertingMixin):
"""A converting tuple wrapper."""
def__getitem__(self, key):
value=tuple.__getitem__(self, key)
# Can't replace a tuple entry.
returnself.convert_with_key(key, value, replace=False)

classBaseConfigurator(object):
"""
 The configurator base class which defines some useful defaults.
 """

CONVERT_PATTERN=re.compile(r'^(?P<prefix>[a-z]+)://(?P<suffix>.*)$')

WORD_PATTERN=re.compile(r'^\s*(\w+)\s*')
DOT_PATTERN=re.compile(r'^\.\s*(\w+)\s*')
INDEX_PATTERN=re.compile(r'^\[\s*(\w+)\s*\]\s*')
DIGIT_PATTERN=re.compile(r'^\d+$')

value_converters= {
'ext' : 'ext_convert',
'cfg' : 'cfg_convert',
 }

# We might want to use a different one, e.g. importlib
importer=staticmethod(__import__)

def__init__(self, config):
self.config=ConvertingDict(config)
self.config.configurator=self

defresolve(self, s):
"""
 Resolve strings to objects using standard import and attribute
 syntax.
 """
name=s.split('.')
used=name.pop(0)
try:
found=self.importer(used)
forfraginname:
used+='.'+frag
try:
found=getattr(found, frag)
exceptAttributeError:
self.importer(used)
found=getattr(found, frag)
returnfound
exceptImportError:
e, tb=sys.exc_info()[1:]
v=ValueError('Cannot resolve %r: %s'% (s, e))
v.__cause__, v.__traceback__=e, tb
raisev

defext_convert(self, value):
"""Default converter for the ext:// protocol."""
returnself.resolve(value)

defcfg_convert(self, value):
"""Default converter for the cfg:// protocol."""
rest=value
m=self.WORD_PATTERN.match(rest)
ifmisNone:
raiseValueError("Unable to convert %r"%value)
else:
rest=rest[m.end():]
d=self.config[m.groups()[0]]
#print d, rest
whilerest:
m=self.DOT_PATTERN.match(rest)
ifm:
d=d[m.groups()[0]]
else:
m=self.INDEX_PATTERN.match(rest)
ifm:
idx=m.groups()[0]
ifnotself.DIGIT_PATTERN.match(idx):
d=d[idx]
else:
try:
n=int(idx) # try as number first (most likely)
d=d[n]
exceptTypeError:
d=d[idx]
ifm:
rest=rest[m.end():]
else:
raiseValueError('Unable to convert '
'%r at %r'% (value, rest))
#rest should be empty
returnd

defconvert(self, value):
"""
 Convert values to an appropriate type. dicts, lists and tuples are
 replaced by their converting alternatives. Strings are checked to
 see if they have a conversion format and are converted if they do.
 """
ifnotisinstance(value, ConvertingDict) andisinstance(value, dict):
value=ConvertingDict(value)
value.configurator=self
elifnotisinstance(value, ConvertingList) andisinstance(value, list):
value=ConvertingList(value)
value.configurator=self
elifnotisinstance(value, ConvertingTuple) and\
isinstance(value, tuple) andnothasattr(value, '_fields'):
value=ConvertingTuple(value)
value.configurator=self
elifisinstance(value, str): # str for py3k
m=self.CONVERT_PATTERN.match(value)
ifm:
d=m.groupdict()
prefix=d['prefix']
converter=self.value_converters.get(prefix, None)
ifconverter:
suffix=d['suffix']
converter=getattr(self, converter)
value=converter(suffix)
returnvalue

defconfigure_custom(self, config):
"""Configure an object with a user-supplied factory."""
c=config.pop('()')
ifnotcallable(c):
c=self.resolve(c)
props=config.pop('.', None)
# Check for valid identifiers
kwargs= {k: config[k] forkinconfigifvalid_ident(k)}
result=c(**kwargs)
ifprops:
forname, valueinprops.items():
setattr(result, name, value)
returnresult

defas_tuple(self, value):
"""Utility function which converts lists to tuples."""
ifisinstance(value, list):
value=tuple(value)
returnvalue

classDictConfigurator(BaseConfigurator):
"""
 Configure logging using a dictionary-like object to describe the
 configuration.
 """

defconfigure(self):
"""Do the configuration."""

config=self.config
if'version'notinconfig:
raiseValueError("dictionary doesn't specify a version")
ifconfig['version'] !=1:
raiseValueError("Unsupported version: %s"%config['version'])
incremental=config.pop('incremental', False)
EMPTY_DICT= {}
logging._acquireLock()
try:
ifincremental:
handlers=config.get('handlers', EMPTY_DICT)
fornameinhandlers:
ifnamenotinlogging._handlers:
raiseValueError('No handler found with '
'name %r'%name)
else:
try:
handler=logging._handlers[name]
handler_config=handlers[name]
level=handler_config.get('level', None)
iflevel:
handler.setLevel(logging._checkLevel(level))
exceptExceptionase:
raiseValueError('Unable to configure handler '
'%r'%name) frome
loggers=config.get('loggers', EMPTY_DICT)
fornameinloggers:
try:
self.configure_logger(name, loggers[name], True)
exceptExceptionase:
raiseValueError('Unable to configure logger '
'%r'%name) frome
root=config.get('root', None)
ifroot:
try:
self.configure_root(root, True)
exceptExceptionase:
raiseValueError('Unable to configure root '
'logger') frome
else:
disable_existing=config.pop('disable_existing_loggers', True)

_clearExistingHandlers()

# Do formatters first - they don't refer to anything else
formatters=config.get('formatters', EMPTY_DICT)
fornameinformatters:
try:
formatters[name] =self.configure_formatter(
formatters[name])
exceptExceptionase:
raiseValueError('Unable to configure '
'formatter %r'%name) frome
# Next, do filters - they don't refer to anything else, either
filters=config.get('filters', EMPTY_DICT)
fornameinfilters:
try:
filters[name] =self.configure_filter(filters[name])
exceptExceptionase:
raiseValueError('Unable to configure '
'filter %r'%name) frome

# Next, do handlers - they refer to formatters and filters
# As handlers can refer to other handlers, sort the keys
# to allow a deterministic order of configuration
handlers=config.get('handlers', EMPTY_DICT)
deferred= []
fornameinsorted(handlers):
try:
handler=self.configure_handler(handlers[name])
handler.name=name
handlers[name] =handler
exceptExceptionase:
if'target not configured yet'instr(e.__cause__):
deferred.append(name)
else:
raiseValueError('Unable to configure handler '
'%r'%name) frome

# Now do any that were deferred
fornameindeferred:
try:
handler=self.configure_handler(handlers[name])
handler.name=name
handlers[name] =handler
exceptExceptionase:
raiseValueError('Unable to configure handler '
'%r'%name) frome

# Next, do loggers - they refer to handlers and filters

#we don't want to lose the existing loggers,
#since other threads may have pointers to them.
#existing is set to contain all existing loggers,
#and as we go through the new configuration we
#remove any which are configured. At the end,
#what's left in existing is the set of loggers
#which were in the previous configuration but
#which are not in the new configuration.
root=logging.root
existing=list(root.manager.loggerDict.keys())
#The list needs to be sorted so that we can
#avoid disabling child loggers of explicitly
#named loggers. With a sorted list it is easier
#to find the child loggers.
existing.sort()
#We'll keep the list of existing loggers
#which are children of named loggers here...
child_loggers= []
#now set up the new ones...
loggers=config.get('loggers', EMPTY_DICT)
fornameinloggers:
ifnameinexisting:
i=existing.index(name) +1# look after name
prefixed=name+"."
pflen=len(prefixed)
num_existing=len(existing)
whilei<num_existing:
ifexisting[i][:pflen] ==prefixed:
child_loggers.append(existing[i])
i+=1
existing.remove(name)
try:
self.configure_logger(name, loggers[name])
exceptExceptionase:
raiseValueError('Unable to configure logger '
'%r'%name) frome

#Disable any old loggers. There's no point deleting
#them as other threads may continue to hold references
#and by disabling them, you stop them doing any logging.
#However, don't disable children of named loggers, as that's
#probably not what was intended by the user.
#for log in existing:
# logger = root.manager.loggerDict[log]
# if log in child_loggers:
# logger.level = logging.NOTSET
# logger.handlers = []
# logger.propagate = True
# elif disable_existing:
# logger.disabled = True
_handle_existing_loggers(existing, child_loggers,
disable_existing)

# And finally, do the root logger
root=config.get('root', None)
ifroot:
try:
self.configure_root(root)
exceptExceptionase:
raiseValueError('Unable to configure root '
'logger') frome
finally:
logging._releaseLock()

defconfigure_formatter(self, config):
"""Configure a formatter from a dictionary."""
if'()'inconfig:
factory=config['()'] # for use in exception handler
try:
result=self.configure_custom(config)
exceptTypeErroraste:
if"'format'"notinstr(te):
raise
#Name of parameter changed from fmt to format.
#Retry with old name.
#This is so that code can be used with older Python versions
#(e.g. by Django)
config['fmt'] =config.pop('format')
config['()'] =factory
result=self.configure_custom(config)
else:
fmt=config.get('format', None)
dfmt=config.get('datefmt', None)
style=config.get('style', '%')
cname=config.get('class', None)
ifnotcname:
c=logging.Formatter
else:
c=_resolve(cname)
result=c(fmt, dfmt, style)
returnresult

defconfigure_filter(self, config):
"""Configure a filter from a dictionary."""
if'()'inconfig:
result=self.configure_custom(config)
else:
name=config.get('name', '')
result=logging.Filter(name)
returnresult

defadd_filters(self, filterer, filters):
"""Add filters to a filterer from a list of names."""
forfinfilters:
try:
filterer.addFilter(self.config['filters'][f])
exceptExceptionase:
raiseValueError('Unable to add filter %r'%f) frome

defconfigure_handler(self, config):
"""Configure a handler from a dictionary."""
config_copy=dict(config) # for restoring in case of error
formatter=config.pop('formatter', None)
ifformatter:
try:
formatter=self.config['formatters'][formatter]
exceptExceptionase:
raiseValueError('Unable to set formatter '
'%r'%formatter) frome
level=config.pop('level', None)
filters=config.pop('filters', None)
if'()'inconfig:
c=config.pop('()')
ifnotcallable(c):
c=self.resolve(c)
factory=c
else:
cname=config.pop('class')
klass=self.resolve(cname)
#Special case for handler which refers to another handler
ifissubclass(klass, logging.handlers.MemoryHandler) and\
'target'inconfig:
try:
th=self.config['handlers'][config['target']]
ifnotisinstance(th, logging.Handler):
config.update(config_copy) # restore for deferred cfg
raiseTypeError('target not configured yet')
config['target'] =th
exceptExceptionase:
raiseValueError('Unable to set target handler '
'%r'%config['target']) frome
elifissubclass(klass, logging.handlers.SMTPHandler) and\
'mailhost'inconfig:
config['mailhost'] =self.as_tuple(config['mailhost'])
elifissubclass(klass, logging.handlers.SysLogHandler) and\
'address'inconfig:
config['address'] =self.as_tuple(config['address'])
factory=klass
props=config.pop('.', None)
kwargs= {k: config[k] forkinconfigifvalid_ident(k)}
try:
result=factory(**kwargs)
exceptTypeErroraste:
if"'stream'"notinstr(te):
raise
#The argument name changed from strm to stream
#Retry with old name.
#This is so that code can be used with older Python versions
#(e.g. by Django)
kwargs['strm'] =kwargs.pop('stream')
result=factory(**kwargs)
ifformatter:
result.setFormatter(formatter)
iflevelisnotNone:
result.setLevel(logging._checkLevel(level))
iffilters:
self.add_filters(result, filters)
ifprops:
forname, valueinprops.items():
setattr(result, name, value)
returnresult

defadd_handlers(self, logger, handlers):
"""Add handlers to a logger from a list of names."""
forhinhandlers:
try:
logger.addHandler(self.config['handlers'][h])
exceptExceptionase:
raiseValueError('Unable to add handler %r'%h) frome

defcommon_logger_config(self, logger, config, incremental=False):
"""
 Perform configuration which is common to root and non-root loggers.
 """
level=config.get('level', None)
iflevelisnotNone:
logger.setLevel(logging._checkLevel(level))
ifnotincremental:
#Remove any existing handlers
forhinlogger.handlers[:]:
logger.removeHandler(h)
handlers=config.get('handlers', None)
ifhandlers:
self.add_handlers(logger, handlers)
filters=config.get('filters', None)
iffilters:
self.add_filters(logger, filters)

defconfigure_logger(self, name, config, incremental=False):
"""Configure a non-root logger from a dictionary."""
logger=logging.getLogger(name)
self.common_logger_config(logger, config, incremental)
propagate=config.get('propagate', None)
ifpropagateisnotNone:
logger.propagate=propagate

defconfigure_root(self, config, incremental=False):
"""Configure a root logger from a dictionary."""
root=logging.getLogger()
self.common_logger_config(root, config, incremental)

dictConfigClass=DictConfigurator

defdictConfig(config):
"""Configure logging using a dictionary."""
dictConfigClass(config).configure()


deflisten(port=DEFAULT_LOGGING_CONFIG_PORT, verify=None):
"""
 Start up a socket server on the specified port, and listen for new
 configurations.

 These will be sent as a file suitable for processing by fileConfig().
 Returns a Thread object on which you can call start() to start the server,
 and which you can join() when appropriate. To stop the server, call
 stopListening().

 Use the ``verify`` argument to verify any bytes received across the wire
 from a client. If specified, it should be a callable which receives a
 single argument - the bytes of configuration data received across the
 network - and it should return either ``None``, to indicate that the
 passed in bytes could not be verified and should be discarded, or a
 byte string which is then passed to the configuration machinery as
 normal. Note that you can return transformed bytes, e.g. by decrypting
 the bytes passed in.
 """

classConfigStreamHandler(StreamRequestHandler):
"""
 Handler for a logging configuration request.

 It expects a completely new logging configuration and uses fileConfig
 to install it.
 """
defhandle(self):
"""
 Handle a request.

 Each request is expected to be a 4-byte length, packed using
 struct.pack(">L", n), followed by the config file.
 Uses fileConfig() to do the grunt work.
 """
try:
conn=self.connection
chunk=conn.recv(4)
iflen(chunk) ==4:
slen=struct.unpack(">L", chunk)[0]
chunk=self.connection.recv(slen)
whilelen(chunk) <slen:
chunk=chunk+conn.recv(slen-len(chunk))
ifself.server.verifyisnotNone:
chunk=self.server.verify(chunk)
ifchunkisnotNone: # verified, can process
chunk=chunk.decode("utf-8")
try:
importjson
d=json.loads(chunk)
assertisinstance(d, dict)
dictConfig(d)
exceptException:
#Apply new configuration.

file=io.StringIO(chunk)
try:
fileConfig(file)
exceptException:
traceback.print_exc()
ifself.server.ready:
self.server.ready.set()
exceptOSErrorase:
ife.errno!=RESET_ERROR:
raise

classConfigSocketReceiver(ThreadingTCPServer):
"""
 A simple TCP socket-based logging config receiver.
 """

allow_reuse_address=1

def__init__(self, host='localhost', port=DEFAULT_LOGGING_CONFIG_PORT,
handler=None, ready=None, verify=None):
ThreadingTCPServer.__init__(self, (host, port), handler)
logging._acquireLock()
self.abort=0
logging._releaseLock()
self.timeout=1
self.ready=ready
self.verify=verify

defserve_until_stopped(self):
importselect
abort=0
whilenotabort:
rd, wr, ex=select.select([self.socket.fileno()],
 [], [],
self.timeout)
ifrd:
self.handle_request()
logging._acquireLock()
abort=self.abort
logging._releaseLock()
self.server_close()

classServer(threading.Thread):

def__init__(self, rcvr, hdlr, port, verify):
super(Server, self).__init__()
self.rcvr=rcvr
self.hdlr=hdlr
self.port=port
self.verify=verify
self.ready=threading.Event()

defrun(self):
server=self.rcvr(port=self.port, handler=self.hdlr,
ready=self.ready,
verify=self.verify)
ifself.port==0:
self.port=server.server_address[1]
self.ready.set()
global_listener
logging._acquireLock()
_listener=server
logging._releaseLock()
server.serve_until_stopped()

returnServer(ConfigSocketReceiver, ConfigStreamHandler, port, verify)

defstopListening():
"""
 Stop the listening server which was created with a call to listen().
 """
global_listener
logging._acquireLock()
try:
if_listener:
_listener.abort=1
_listener=None
finally:
logging._releaseLock()