"""
+import os.path
import logging
import logging.handlers
+from cStringIO import StringIO
from ganeti import constants
+from ganeti import compat
class _ReopenableLogHandler(logging.handlers.BaseRotatingHandler):
self._reopen = False
- def shouldRollover(self, _): # pylint: disable-msg=C0103
+ def shouldRollover(self, _): # pylint: disable=C0103
"""Determine whether log file should be reopened.
"""
return self._reopen or not self.stream
- def doRollover(self): # pylint: disable-msg=C0103
+ def doRollover(self): # pylint: disable=C0103
"""Reopens the log file.
"""
# TODO: Handle errors?
self.stream = open(self.baseFilename, "a")
+ # Don't reopen on the next message
+ self._reopen = False
+
def RequestReopen(self):
"""Register a request to reopen the file.
This needs to be in a function for unittesting.
"""
- class wrapped(base): # pylint: disable-msg=C0103
+ class wrapped(base): # pylint: disable=C0103
"""Log handler that doesn't fallback to stderr.
When an error occurs while writing on the logfile, logging.FileHandler
assert not hasattr(self, "_console")
self._console = console
- def handleError(self, record): # pylint: disable-msg=C0103
+ def handleError(self, record): # pylint: disable=C0103
"""Handle errors which occur during an emit() call.
Try to handle errors with FileHandler method, if it fails write to
"""
try:
base.handleError(record)
- except Exception: # pylint: disable-msg=W0703
+ except Exception: # pylint: disable=W0703
if self._console:
try:
- # Ignore warning about "self.format", pylint: disable-msg=E1101
+ # Ignore warning about "self.format", pylint: disable=E1101
self._console.write("Cannot log message:\n%s\n" %
self.format(record))
- except Exception: # pylint: disable-msg=W0703
+ except Exception: # pylint: disable=W0703
# Log handler tried everything it could, now just give up
pass
return logging.Formatter("".join(parts))
-def SetupLogging(logfile, debug=0, stderr_logging=False, program="",
+def _ReopenLogFiles(handlers):
+ """Wrapper for reopening all log handler's files in a sequence.
+
+ """
+ for handler in handlers:
+ handler.RequestReopen()
+ logging.info("Received request to reopen log files")
+
+
+def SetupLogging(logfile, program, debug=0, stderr_logging=False,
multithreaded=False, syslog=constants.SYSLOG_USAGE,
- console_logging=False):
+ console_logging=False, root_logger=None):
"""Configures the logging module.
@type logfile: str
@param logfile: the filename to which we should log
+ @type program: str
+ @param program: the name under which we should log messages
@type debug: integer
@param debug: if greater than zero, enable debug messages, otherwise
only those at C{INFO} and above level
@type stderr_logging: boolean
@param stderr_logging: whether we should also log to the standard error
- @type program: str
- @param program: the name under which we should log messages
@type multithreaded: boolean
@param multithreaded: if True, will add the thread name to the log file
@type syslog: string
@type console_logging: boolean
@param console_logging: if True, will use a FileHandler which falls back to
the system console if logging fails
+ @type root_logger: logging.Logger
+ @param root_logger: Root logger to use (for unittests)
@raise EnvironmentError: if we can't open the log file and
syslog/stderr logging is disabled
+ @rtype: callable
+ @return: Function reopening all open log files when called
"""
- formatter = _GetLogFormatter(program, multithreaded, debug, False)
- syslog_fmt = _GetLogFormatter(program, multithreaded, debug, True)
+ progname = os.path.basename(program)
+
+ formatter = _GetLogFormatter(progname, multithreaded, debug, False)
+ syslog_fmt = _GetLogFormatter(progname, multithreaded, debug, True)
+
+ reopen_handlers = []
- root_logger = logging.getLogger("")
+ if root_logger is None:
+ root_logger = logging.getLogger("")
root_logger.setLevel(logging.NOTSET)
# Remove all previously setup handlers
# exception since otherwise we could run but without any logs at all
try:
if console_logging:
- logfile_handler = _LogHandler(open(constants.DEV_CONSOLE, "a"), logfile)
+ logfile_handler = _LogHandler(open(constants.DEV_CONSOLE, "a"),
+ logfile)
else:
logfile_handler = _ReopenableLogHandler(logfile)
else:
logfile_handler.setLevel(logging.INFO)
root_logger.addHandler(logfile_handler)
+ reopen_handlers.append(logfile_handler)
except EnvironmentError:
if stderr_logging or syslog == constants.SYSLOG_YES:
logging.exception("Failed to enable logging to file '%s'", logfile)
else:
# we need to re-raise the exception
raise
+
+ return compat.partial(_ReopenLogFiles, reopen_handlers)
+
+
+def SetupToolLogging(debug, verbose, threadname=False,
+ _root_logger=None, _stream=None):
+ """Configures the logging module for tools.
+
+ All log messages are sent to stderr.
+
+ @type debug: boolean
+ @param debug: Disable log message filtering
+ @type verbose: boolean
+ @param verbose: Enable verbose log messages
+ @type threadname: boolean
+ @param threadname: Whether to include thread name in output
+
+ """
+ if _root_logger is None:
+ root_logger = logging.getLogger("")
+ else:
+ root_logger = _root_logger
+
+ fmt = StringIO()
+ fmt.write("%(asctime)s:")
+
+ if threadname:
+ fmt.write(" %(threadName)s")
+
+ if debug or verbose:
+ fmt.write(" %(levelname)s")
+
+ fmt.write(" %(message)s")
+
+ formatter = logging.Formatter(fmt.getvalue())
+
+ stderr_handler = logging.StreamHandler(_stream)
+ stderr_handler.setFormatter(formatter)
+ if debug:
+ stderr_handler.setLevel(logging.NOTSET)
+ elif verbose:
+ stderr_handler.setLevel(logging.INFO)
+ else:
+ stderr_handler.setLevel(logging.WARNING)
+
+ root_logger.setLevel(logging.NOTSET)
+ root_logger.addHandler(stderr_handler)
projects / ganeti-local / blobdiff