Use the python logging module under the hood for bb.msg

(Bitbake rev: 47ca82397bc395b598c6b68b24cdee9e0d8a76d8)

Signed-off-by: Chris Larson <chris_larson@mentor.com>
Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>

1 files changed, 68 insertions, 66 deletions

diff --git a/bitbake/lib/bb/msg.py b/bitbake/lib/bb/msg.py
index 21692d930d..254ba07a04 100644
--- a/bitbake/lib/bb/msg.py
+++ b/bitbake/lib/bb/msg.py
@@ -23,12 +23,26 @@ Message handling infrastructure for bitbake
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 import sys
+import logging
 import collections
+from itertools import groupby
 import bb
 import bb.event
 
-debug_level = collections.defaultdict(lambda: 0)
-verbose = False
+class Loggers(dict):
+    def __getitem__(self, key):
+        if key in self:
+            return dict.__getitem__(self, key)
+        else:
+            log = logging.getLogger("BitBake.%s" % domain._fields[key])
+            dict.__setitem__(self, key, log)
+            return log
+
+class DebugLevel(dict):
+    def __getitem__(self, key):
+        if key == "default":
+            key = domain.Default
+        return get_debug_level(key)
 
 def _NamedTuple(name, fields):
     Tuple = collections.namedtuple(name, " ".join(fields))
@@ -49,96 +63,84 @@ domain = _NamedTuple("Domain", (
     "TaskData",
     "Util"))
 
-
-class MsgBase(bb.event.Event):
-    """Base class for messages"""
-
-    def __init__(self, msg):
-        self._message = msg
-        bb.event.Event.__init__(self)
-
-class MsgDebug(MsgBase):
-    """Debug Message"""
-
-class MsgNote(MsgBase):
-    """Note Message"""
-
-class MsgWarn(MsgBase):
-    """Warning Message"""
-
-class MsgError(MsgBase):
-    """Error Message"""
-
-class MsgFatal(MsgBase):
-    """Fatal Message"""
-
-class MsgPlain(MsgBase):
-    """General output"""
+logger = logging.getLogger("BitBake")
+loggers = Loggers()
+debug_level = DebugLevel()
 
 #
 # Message control functions
 #
 
 def set_debug_level(level):
-    for d in domain:
-        debug_level[d] = level
-    debug_level[domain.Default] = level
+    for log in loggers.itervalues():
+        log.setLevel(logging.NOTSET)
+
+    if level:
+        logger.setLevel(logging.DEBUG - level + 1)
+    else:
+        logger.setLevel(logging.INFO)
 
 def get_debug_level(msgdomain = domain.Default):
-    return debug_level[msgdomain]
+    if not msgdomain:
+        level = logger.getEffectiveLevel()
+    else:
+        level = loggers[msgdomain].getEffectiveLevel()
+    return max(0, logging.DEBUG - level + 1)
 
 def set_verbose(level):
-    verbose = level
-
-def set_debug_domains(strdomains):
-    for domainstr in strdomains:
-        for d in domain:
-            if domain._fields[d] == domainstr:
-                debug_level[d] += 1
+    if level:
+        logger.setLevel(logging.INFO - 1)
+    else:
+        logger.setLevel(logging.INFO)
+
+def set_debug_domains(domainargs):
+    for (domainarg, iterator) in groupby(domainargs):
+        for index, msgdomain in enumerate(domain._fields):
+            if msgdomain == domainarg:
+                level = len(tuple(iterator))
+                if level:
+                    loggers[index].setLevel(logging.DEBUG - level + 1)
                 break
         else:
-            warn(None, "Logging domain %s is not valid, ignoring" % domainstr)
+            warn(None, "Logging domain %s is not valid, ignoring" % domainarg)
 
 #
 # Message handling functions
 #
 
 def debug(level, msgdomain, msg, fn = None):
+    level = logging.DEBUG - (level - 1)
     if not msgdomain:
-        msgdomain = domain.Default
-
-    if debug_level[msgdomain] >= level:
-        bb.event.fire(MsgDebug(msg), None)
-        if bb.event.useStdout:
-            print('DEBUG: %s' % (msg))
+        logger.log(level, msg)
+    else:
+        loggers[msgdomain].log(level, msg)
 
+def plain(msg, fn = None):
+    logger.log(logging.INFO + 1, msg)
+ 
 def note(level, msgdomain, msg, fn = None):
+    level = logging.INFO - (level - 1)
     if not msgdomain:
-        msgdomain = domain.Default
-
-    if level == 1 or verbose or debug_level[msgdomain] >= 1:
-        bb.event.fire(MsgNote(msg), None)
-        if bb.event.useStdout:
-            print('NOTE: %s' % (msg))
-
+        logger.log(level, msg)
+    else:
+        loggers[msgdomain].log(level, msg)
+ 
 def warn(msgdomain, msg, fn = None):
-    bb.event.fire(MsgWarn(msg), None)
-    if bb.event.useStdout:
-        print('WARNING: %s' % (msg))
+    if not msgdomain:
+        logger.warn(msg)
+    else:
+        loggers[msgdomain].warn(msg)
 
 def error(msgdomain, msg, fn = None):
-    bb.event.fire(MsgError(msg), None)
-    if bb.event.useStdout:
-       print('ERROR: %s' % (msg))
+    if not msgdomain:
+        logger.error(msg)
+    else:
+        loggers[msgdomain].error(msg)
 
 def fatal(msgdomain, msg, fn = None):
-    bb.event.fire(MsgFatal(msg), None)
-
-    if bb.event.useStdout:
-        print('FATAL: %s' % (msg))
+    if not msgdomain:
+        logger.critical(msg)
+    else:
+        loggers[msgdomain].critical(msg)
     sys.exit(1)
 
-def plain(msg, fn = None):
-    bb.event.fire(MsgPlain(msg), None)
-    if bb.event.useStdout:
-        print(msg)