Refactoring for fileConfig. Contributed by Shane Hathaway.

Lib/logging/config.py

@@ -72,9 +72,25 @@ def fileConfig(fname, defaults=None):
         cp.readfp(fname)
     else:
         cp.read(fname)
-    #first, do the formatters...
+
+    formatters = _create_formatters(cp)
+
+    # critical section
+    logging._acquireLock()
+    try:
+        logging._handlers.clear()
+        # Handlers add themselves to logging._handlers
+        handlers = _install_handlers(cp, formatters)
+        _install_loggers(cp, handlers)
+    finally:
+        logging._releaseLock()
+
+
+def _create_formatters(cp):
+    """Create and return formatters"""
     flist = cp.get("formatters", "keys")
-    if len(flist):
+    if not len(flist):
+        return {}
     flist = string.split(flist, ",")
     formatters = {}
     for form in flist:
@@ -90,21 +106,18 @@ def fileConfig(fname, defaults=None):
             dfs = None
         f = logging.Formatter(fs, dfs)
         formatters[form] = f
-    #next, do the handlers...
-    #critical section...
-    logging._acquireLock()
-    try:
-        try:
-            #first, lose the existing handlers...
-            logging._handlers.clear()
-            #now set up the new ones...
+    return formatters
+
+
+def _install_handlers(cp, formatters):
+    """Install and return handlers"""
     hlist = cp.get("handlers", "keys")
-            if len(hlist):
+    if not len(hlist):
+        return {}
     hlist = string.split(hlist, ",")
     handlers = {}
     fixups = [] #for inter-handler references
     for hand in hlist:
-                    try:
         sectname = "handler_%s" % hand
         klass = cp.get(sectname, "class")
         opts = cp.options(sectname)
@@ -130,14 +143,16 @@ def fileConfig(fname, defaults=None):
             if len(target): #the target handler may not be loaded yet, so keep for later...
                 fixups.append((h, target))
         handlers[hand] = h
-                    except:     #if an error occurs when instantiating a handler, too bad
-                        pass    #this could happen e.g. because of lack of privileges
     #now all handlers are loaded, fixup inter-handler references...
-                for fixup in fixups:
-                    h = fixup[0]
-                    t = fixup[1]
+    for h, t in fixups:
         h.setTarget(handlers[t])
-            #at last, the loggers...first the root...
+    return handlers
+
+
+def _install_loggers(cp, handlers):
+    """Create and install loggers"""
+
+    # configure the root first
     llist = cp.get("loggers", "keys")
     llist = string.split(llist, ",")
     llist.remove("root")
@@ -155,6 +170,7 @@ def fileConfig(fname, defaults=None):
         hlist = string.split(hlist, ",")
         for hand in hlist:
             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.
@@ -189,17 +205,13 @@ def fileConfig(fname, defaults=None):
             hlist = string.split(hlist, ",")
             for hand in hlist:
                 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.
     for log in existing:
         root.manager.loggerDict[log].disabled = 1
-        except:
-            ei = sys.exc_info()
-            traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)
-            del ei
-    finally:
-        logging._releaseLock()
+
 
 def listen(port=DEFAULT_LOGGING_CONFIG_PORT):
     """
@@ -247,7 +259,12 @@ def listen(port=DEFAULT_LOGGING_CONFIG_PORT):
                     f = open(file, "w")
                     f.write(chunk)
                     f.close()
+                    try:
                         fileConfig(file)
+                    except (KeyboardInterrupt, SystemExit):
+                        raise
+                    except:
+                        traceback.print_exc()
                     os.remove(file)
             except socket.error, e:
                 if type(e.args) != types.TupleType: