commit 748093a15a7e221c0210b43fa17b87e58e29578a
Author: Ondrej Lichtner <olichtne(a)redhat.com>
Date: Fri Mar 8 16:24:39 2013 +0100
Logs: code removal
This commit removes old deprecated code, in preparation for the
reimplementation of how we work with the logging module.
I completely removed the class stdLogger because its sole purpose was to
introduce a side-effect when importing the file. We decided that we
don't want this functionality or any side-effects anymore.
I also removed the static class Logs because the code was too complex to
use, understand and maintain. The reimplementation is focusing on this
class, the new implementation will be present in the following commit.
Finally one smaller change- I removed the global constant LOCAL_IP and
placed its value into a variable of the MultilineFormatter class as this
was the only place it was ever used and I failed to see a reason to keep
it as a global constant.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
lnst/Common/Logs.py | 240 +--------------------------------------------------
1 files changed, 2 insertions(+), 238 deletions(-)
---
diff --git a/lnst/Common/Logs.py b/lnst/Common/Logs.py
index 4932c85..15a11a6 100644
--- a/lnst/Common/Logs.py
+++ b/lnst/Common/Logs.py
@@ -14,8 +14,7 @@ from logging import Formatter
import logging.handlers
import traceback
from lnst.Common.LoggingHandler import LogBuffer
-
-LOCAL_IP = "(127.0.0.1)"
+from lnst.Common.LoggingHandler import TransmitHandler
def log_exc_traceback():
cmd_type, value, tb = sys.exc_info()
@@ -49,7 +48,7 @@ class MultilineFormater(Formatter):
"""
record.message = record.getMessage()
if not "address" in record.__dict__:
- record.address = LOCAL_IP
+ record.address = "(127.0.0.1)"
if self._fmt.find("%(asctime)") >= 0:
record.asctime = self.formatTime(record, self.datefmt)
lines = record.__dict__["message"].split("\n")
@@ -75,238 +74,3 @@ class MultilineFormater(Formatter):
# See issue 8924
s = s + record.exc_text.decode(sys.getfilesystemencoding())
return s
-
-
-class stdLogger(logging.Logger):
- def __init__(self, name, level=logging.NOTSET):
- logging.Logger.__init__(self, name, level)
-
- def findCaller(self):
- """
- Find the stack frame of the caller so that we can note the source
- file name, line number and function name.
- """
- rv = "stdio", 0, "(unknown function)"
- return rv
-
-logging._acquireLock()
-try:
- logging.setLoggerClass(stdLogger)
- logging.getLogger("root.stdLogger")
- logging.setLoggerClass(logging.Logger)
-finally:
- logging._releaseLock()
-
-
-class LoggingFile(object):
- """
- File-like object that will receive messages pass them to the logging
- infrastructure in an appropriate way.
- """
- def __init__(self, prefix='', level=logging.DEBUG):
- """
- @param prefix - The prefix for each line logged by this object.
- """
- self._prefix = prefix
- self._level = level
- self._buffer = []
- self._stdLogger = logging.getLogger("root.stdLogger")
-
-
- def write(self, data):
- """"
- Writes data only if it constitutes a whole line. If it's not the case,
- store it in a buffer and wait until we have a complete line.
- @param data - Raw data (a string) that will be processed.
- """
- # splitlines() discards a trailing blank line, so use split() instead
- data_lines = data.split('\n')
- if len(data_lines) > 1:
- self._buffer.append(data_lines[0])
- self._flush_buffer()
- for line in data_lines[1:-1]:
- self._log_line(line)
- if data_lines[-1]:
- self._buffer.append(data_lines[-1])
-
-
- def _log_line(self, line):
- """
- Passes lines of output to the logging module.
- """
- self._stdLogger.log(self._level, self._prefix + line)
-
-
- def _flush_buffer(self):
- if self._buffer:
- self._log_line(''.join(self._buffer))
- self._buffer = []
-
-
- def flush(self):
- self._flush_buffer()
-
-
-class Logs:
- formatter = None
- logFolder = None
- loggers = []
- root_path = None
- debug = None
- date = None
- nameExtend = None
- state = None
- @classmethod
- def __init__(cls,debug=0, waitForNet=False, logger=logging.getLogger(),
- recipe_path=None, to_display=True, date=None,
- nameExtend=None, log_folder=None):
- logging.addLevelName(5, "DEBUG2")
- logging.DEBUG2 = 5
- if nameExtend is None:
- nameExtend = ""
- else:
- nameExtend = "_" + nameExtend
- cls.formatter = MultilineFormater(
- '%(asctime)s| %(address)17.17s%(module)15.15s'
- ':%(lineno)4.4d| %(levelname)s: '
- '%(message)s', '%d/%m %H:%M:%S', "
"*4)
- if log_folder != None:
- cls.logFolder = log_folder
- else:
- cls.logFolder = os.path.join(os.path.dirname(sys.argv[0]), './Logs')
- cls.loggers.append(logger)
- cls.debug = debug
- if date is None:
- cls.date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
- else:
- cls.date = date
- cls.nameExtend = nameExtend
- cls.root_path = cls.prepare_logging(debug, waitForNet,
- recipe_path, to_display)
-
- @classmethod
- def relocate_log_folder(cls, date=None, log_folder=None, nameExtend=None):
- root_logger = logging.getLogger()
- if log_folder != None:
- cls.logFolder = log_folder
- else:
- cls.logFolder = os.path.join(os.path.dirname(sys.argv[0]), './Logs')
-
- if date is None:
- cls.date = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
- else:
- cls.date = date
-
- if nameExtend != None:
- cls.nameExtend = "_" + nameExtend
- else:
- cls.nameExtend = ""
- cls.log_root_folder = cls.set_logging_root_path(None, True)
-
- @classmethod
- def save_state(cls):
- cls.state = {"logFolder": cls.logFolder, "date": cls.date}
-
- @classmethod
- def reset_state(cls):
- cls.logFolder = cls.state["logFolder"]
- cls.date = cls.state["date"]
-
- for logger in cls.loggers:
- handlers = list(logger.handlers)
- for handler in handlers:
- if isinstance(handler, logging.FileHandler):
- handler.close()
- logger.removeHandler(handler)
-
- cls.loggers = cls.loggers[:1]
-
- @classmethod
- def clean_root_log_folder(cls, logRootPath):
- try:
- shutil.rmtree(logRootPath)
- except OSError as e:
- if e.errno != 2:
- raise
- os.makedirs(logRootPath)
-
- @classmethod
- def _create_file_handler(cls, path):
- file_debug = logging.FileHandler(os.path.join(path, 'debug'))
- file_debug.setFormatter(cls.formatter)
- file_debug.setLevel(logging.NOTSET)
-
- file_info = logging.FileHandler(os.path.join(path, 'info'))
- file_info.setFormatter(cls.formatter)
- file_info.setLevel(logging.INFO)
-
- return (file_debug, file_info)
-
-
- @classmethod
- def set_logging_root_path(cls, recipe_path=None, clean=True):
- """
- Change file handlers path.
- """
-
- if recipe_path is None:
- recipe_path = ""
- root_logger = cls.loggers[-1]
- recipe_name = os.path.splitext(os.path.split(recipe_path)[1])[0]
- cls.root_path = os.path.join(cls.logFolder, cls.date+cls.nameExtend,
- recipe_name)
- if (clean):
- cls.clean_root_log_folder(cls.root_path)
-
- handlers = list(root_logger.handlers)
- for handler in handlers:
- if isinstance(handler, logging.FileHandler):
- handler.close()
- root_logger.removeHandler(handler)
-
- (file_debug, file_info) = cls._create_file_handler(cls.root_path)
- root_logger.addHandler(file_debug)
- root_logger.addHandler(file_info)
- return cls.root_path
-
-
- @classmethod
- def get_logging_root_path(cls):
- return cls.root_path
-
- @classmethod
- def get_buffer(cls):
- return cls.buffer
-
- @classmethod
- def prepare_logging(cls, debug=0, waitForNet=False,
- recipe_path=None, to_display=True):
- """
- Configure logging.
-
- @param debug: If True print to terminal debug level of logging messages.
- """
- root_logger = cls.loggers[-1]
- if to_display:
- display = logging.StreamHandler()
- display.setFormatter(cls.formatter)
- if not debug:
- display.setLevel(logging.INFO)
- else:
- if debug == 1:
- display.setLevel(logging.DEBUG)
- else:
- display.setLevel(logging.NOTSET)
- root_logger.addHandler(display)
-
- if waitForNet:
- handler = LogBuffer()
- cls.buffer = handler
- root_logger.addHandler(handler)
-
- log_root_folder = cls.set_logging_root_path(recipe_path)
-
- root_logger.setLevel(logging.NOTSET)
- sys.stdout = LoggingFile(level=logging.INFO)
- sys.stderr = LoggingFile(level=logging.ERROR)
- return log_root_folder