home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / hplip / base / logger.py < prev    next >
Encoding:
Python Source  |  2006-08-30  |  6.4 KB  |  197 lines
  1. # -*- coding: utf-8 -*-
  2. #
  3. # (c) Copyright 2002-2006 Hewlett-Packard Development Company, L.P.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18. #
  19. # Authors: Doug Deprenger, Don Welch
  20. #
  21.  
  22. # Std Lib
  23. import sys, thread, syslog, traceback, string
  24.  
  25.  
  26.  
  27. identity = string.maketrans('','')
  28. unprintable = identity.translate(identity, string.printable)
  29.  
  30. def printable(s):
  31.     return s.translate(identity, unprintable)
  32.  
  33.  
  34. DEFAULT_LOG_LEVEL = 'info'
  35.  
  36. class Logger(object):
  37.  
  38.     LOG_LEVEL_NONE = 99
  39.     LOG_LEVEL_FATAL = 6
  40.     LOG_LEVEL_ERROR = 5
  41.     LOG_LEVEL_WARN = 4
  42.     LOG_LEVEL_INFO = 3
  43.     LOG_LEVEL_DEBUG = 2
  44.     LOG_LEVEL_DBG = 2
  45.  
  46.     logging_levels = {'none' : LOG_LEVEL_NONE,
  47.                        'fata' : LOG_LEVEL_FATAL,
  48.                        'fatal' : LOG_LEVEL_FATAL,
  49.                        'erro' : LOG_LEVEL_ERROR,
  50.                        'error' : LOG_LEVEL_ERROR,
  51.                        'warn' : LOG_LEVEL_WARN,
  52.                        'info' : LOG_LEVEL_INFO,
  53.                        'debu' : LOG_LEVEL_DEBUG,
  54.                        'debug' : LOG_LEVEL_DEBUG}
  55.  
  56.  
  57.     LOG_TO_DEV_NULL = 0
  58.     LOG_TO_CONSOLE = 1
  59.     LOG_TO_SCREEN = 1
  60.     LOG_TO_FILE = 2
  61.     LOG_TO_CONSOLE_AND_FILE = 3
  62.     LOG_TO_BOTH = 3
  63.  
  64.  
  65.     def __init__(self, module='', level=LOG_LEVEL_INFO, where=LOG_TO_CONSOLE_AND_FILE,
  66.                  log_datetime=False, log_file=None):
  67.  
  68.         self.set_level(level)
  69.         self._where = where
  70.         self._log_file = log_file
  71.         self._log_datetime = log_datetime
  72.         self._lock = thread.allocate_lock()
  73.         self.module = module
  74.  
  75.     def set_level(self, level):
  76.         if isinstance(level,str):
  77.             level = level[:4].lower()
  78.  
  79.             if level in Logger.logging_levels.keys():
  80.                 self._level = Logger.logging_levels.get(level, Logger.LOG_LEVEL_INFO)
  81.                 return True
  82.             else:
  83.                 self.error("Invalid logging level: %s" % level)
  84.                 return False
  85.  
  86.         elif isinstance(level,int):
  87.             if Logger.LOG_LEVEL_DEBUG <= level <= Logger.LOG_LEVEL_FATAL:
  88.                 self._level = level
  89.             else:
  90.                 self.error("Invalid logging level: %d" % level)
  91.                 return False
  92.  
  93.         else:
  94.             return False
  95.  
  96.     def set_module(self, module):
  97.         self.module = module
  98.  
  99.  
  100.     def set_logfile(self, log_file):
  101.         self._log_file = log_file
  102.         try:
  103.             self._log_file_f = file(self._log_file, 'w')
  104.         except IOError:
  105.             self._log_file = None
  106.  
  107.     def set_where(self, where):
  108.         self._where = where
  109.  
  110.     def get_level(self):
  111.         return self._level
  112.         
  113.     def is_debug(self):
  114.         return self._level == Logger.LOG_LEVEL_DEBUG
  115.  
  116.     level = property(get_level, set_level)
  117.  
  118.     
  119.     def log(self, message, level):
  120.         if self._where in (Logger.LOG_TO_CONSOLE, Logger.LOG_TO_CONSOLE_AND_FILE):
  121.             try:
  122.                 self._lock.acquire()
  123.                 if level >= Logger.LOG_LEVEL_WARN:
  124.                     out = sys.stderr
  125.                 else:
  126.                     out = sys.stdout
  127.                 out.write(message)
  128.                 out.write('\n')
  129.             finally:
  130.                 self._lock.release()
  131.  
  132.         if self._log_file is not None and \
  133.             self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  134.  
  135.             try:
  136.                 self._lock.acquire()
  137.                 #self._log_file_f.write(printable(message))
  138.                 self._log_file_f.write(message.replace('\x1b', ''))
  139.                 self._log_file_f.write('\n')
  140.  
  141.             finally:
  142.                 self._lock.release()
  143.  
  144.  
  145.     def stderr(self, message):
  146.         try:
  147.             self._lock.acquire()
  148.             sys.stderr.write(message)
  149.             sys.stderr.write('\n')
  150.         finally:
  151.             self._lock.release()
  152.  
  153.     def debug(self, message):
  154.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  155.             self.log("%s%s [DEBUG]: %s%s" % ('\x1b[34;01m', self.module, message, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  156.             syslog.syslog(syslog.LOG_DEBUG, "%s [DEBUG] %s" % (self.module, message))
  157.  
  158.     dbg = debug
  159.     
  160.     def debug_block(self, title, block):
  161.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  162.             self.log("%s%s [DEBUG]: %s:%s" % ('\x1b[34;01m', self.module, title, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  163.             self.log("%s%s%s" % ('\x1b[34;01m', block, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  164.  
  165.     def info(self, message):
  166.         if self._level <= Logger.LOG_LEVEL_INFO:
  167.             if self.module:
  168.                 self.log("%s %s" % (self.module, message), Logger.LOG_LEVEL_INFO)
  169.             else:
  170.                 self.log(message, Logger.LOG_LEVEL_INFO)
  171.  
  172.     information = info
  173.  
  174.     def warn(self, message):
  175.         if self._level <= Logger.LOG_LEVEL_WARN:
  176.             self.log("%s%s [WARNING]: %s%s" % ('\x1b[31;01m', self.module, message, '\x1b[0m'), Logger.LOG_LEVEL_WARN)
  177.             syslog.syslog(syslog.LOG_WARNING, "%s [WARN] %s" % (self.module, message))
  178.  
  179.     warning = warn
  180.  
  181.     def error(self, message):
  182.         if self._level <= Logger.LOG_LEVEL_ERROR:
  183.             self.log("%s%s [ERROR]: %s%s" % ('\x1b[31;01m', self.module, message, '\x1b[0m'), Logger.LOG_LEVEL_ERROR)
  184.             syslog.syslog(syslog.LOG_ALERT, "%s [ERROR] %s" % (self.module, message))
  185.  
  186.     def fatal(self, message):
  187.         if self._level <= Logger.LOG_LEVEL_FATAL:
  188.             self.log("%s%s [FATAL]: %s%s" % ('\x1b[31;01m', self.module, message, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  189.             syslog.syslog(syslog.LOG_CRIT, "%s [FATAL] %s" % (self.module, message))
  190.  
  191.     def exception(self):
  192.         typ, value, tb = sys.exc_info()
  193.         body = "Traceback (innermost last):\n"
  194.         lst = traceback.format_tb(tb) + traceback.format_exception_only(typ, value)
  195.         body = body + "%-20s %s" % (''.join(lst[:-1]), lst[-1],)
  196.         self.fatal(body)
  197.