Merge extensions/python/xpcom changes from DOM_AGNOSTIC2_BRANCH into the

trunk.


git-svn-id: svn://10.0.0.236/trunk@187878 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/extensions/python/xpcom/__init__.py

@@ -39,18 +39,10 @@
 # The XPCOM (Cross Platform COM) package.
 import exceptions
 
-
-import sys
-#sys.stdout = open("pystdout.log", "w")
-if sys.version_info >= (2, 3):
-    # sick off the new hex() warnings, and no time to digest what the 
-    # impact will be!
-    import warnings
-    warnings.filterwarnings("ignore", category=FutureWarning, append=1)
-
 # A global "verbose" flag - currently used by the
 # server package to print trace messages
 verbose = 0
+# Map of nsresult -> constant_name.
 hr_map = {}
 
 # The standard XPCOM exception object.
@@ -72,10 +64,10 @@ class Exception(exceptions.Exception):
             message = hr_map.get(self.errno)
             if message is None:
                 message = ""
-        return "0x%x (%s)" % (self.errno, message)
+        return "%d (%s)" % (self.errno, message)
 
 # An alias for Exception - allows code to say "from xpcom import COMException"
-# rather than "Exception" - thereby preventing clashes.
+# rather than "Exception", preventing clashes with the builtin Exception
 COMException = Exception
 
 # Exceptions thrown by servers.  It can be good for diagnostics to
@@ -83,7 +75,7 @@ COMException = Exception
 # and a normal exception which may simply be propagating down.
 # (When ServerException objects are thrown across the XPConnect
 # gateway they will be converted back to normal client exceptions if
-# subsequently re-caught by Python
+# subsequently re-caught by Python)
 class ServerException(Exception):
     def __init__(self, errno=None, *args, **kw):
         if errno is None:
@@ -91,4 +83,82 @@ class ServerException(Exception):
             errno = nsError.NS_ERROR_FAILURE
         Exception.__init__(self, errno, *args, **kw)
 
-# Some global functions.
+# Logging support - setup the 'xpcom' logger to write to the Mozilla
+# console service, and also to sys.stderr, or optionally a file.
+# Environment variables supports:
+# PYXPCOM_LOG_FILE=filename - if set, used instead of sys.stderr.
+# PYXPCOM_LOG_LEVEL=level - level may be a number or a logging level
+#                           constant (eg, 'debug', 'error')
+# Later it may make sense to allow a different log level to be set for
+# the file than for the console service.
+import logging
+class ConsoleServiceStream:
+    # enough of a stream to keep logging happy
+    def flush(self):
+        pass
+    def write(self, msg):
+        import _xpcom
+        _xpcom.LogConsoleMessage(msg)
+    def close(self):
+        pass
+
+def setupLogging():
+    import sys, os, threading, thread
+    hdlr = logging.StreamHandler(ConsoleServiceStream())
+    fmt = logging.Formatter(logging.BASIC_FORMAT)
+    hdlr.setFormatter(fmt)
+    # There is a bug in 2.3 and 2.4.x logging module in that it doesn't
+    # use an RLock, leading to deadlocks in some cases (specifically,
+    # logger.warning("ob is %r", ob), and where repr(ob) itself tries to log)
+    # Later versions of logging use an RLock, so we detect an "old" style
+    # handler and update its lock
+    if type(hdlr.lock) == thread.LockType:
+        hdlr.lock = threading.RLock()
+
+    logger.addHandler(hdlr)
+    # The console handler in mozilla does not go to the console!?
+    # Add a handler to print to stderr, or optionally a file
+    # PYXPCOM_LOG_FILE can specify a filename
+    filename = os.environ.get("PYXPCOM_LOG_FILE")
+    stream = sys.stderr # this is what logging uses as default
+    if filename:
+        try:
+            # open without buffering so never pending output
+            stream = open(filename, "wU", 0)
+        except IOError, why:
+            print >> sys.stderr, "pyxpcom failed to open log file '%s': %s" \
+                                 % (filename, why)
+            # stream remains default
+
+    hdlr = logging.StreamHandler(stream)
+    # see above - fix a deadlock problem on this handler too.
+    if type(hdlr.lock) == thread.LockType:
+        hdlr.lock = threading.RLock()
+
+    fmt = logging.Formatter(logging.BASIC_FORMAT)
+    hdlr.setFormatter(fmt)
+    logger.addHandler(hdlr)
+    # Allow PYXPCOM_LOG_LEVEL to set the level
+    level = os.environ.get("PYXPCOM_LOG_LEVEL")
+    if level:
+        try:
+            level = int(level)
+        except ValueError:
+            try:
+                # might be a symbolic name - all are upper-case
+                level = int(getattr(logging, level.upper()))
+            except (AttributeError, ValueError):
+                logger.warning("The PYXPCOM_LOG_LEVEL variable specifies an "
+                               "invalid level")
+                level = None
+        if level:
+            logger.setLevel(level)
+
+logger = logging.getLogger('xpcom')
+# If someone else has already setup this logger, leave things alone.
+if len(logger.handlers) == 0:
+    setupLogging()
+
+# Cleanup namespace - but leave 'logger' there for people to use, so they
+# don't need to know the exact name of the logger.
+del ConsoleServiceStream, logging, setupLogging