home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / hplip / base / logger.py < prev    next >
Encoding:
Python Source  |  2007-04-04  |  8.3 KB  |  239 lines
  1. # -*- coding: utf-8 -*-
  2. #
  3. # (c) Copyright 2002-2007 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, os
  24.  
  25. identity = string.maketrans('','')
  26. unprintable = identity.translate(identity, string.printable)
  27.  
  28. def printable(s):
  29.     return s.translate(identity, unprintable)
  30.  
  31.  
  32. DEFAULT_LOG_LEVEL = 'info'
  33.  
  34. class Logger(object):
  35.  
  36.     LOG_LEVEL_NONE = 99
  37.     LOG_LEVEL_FATAL = 6
  38.     LOG_LEVEL_ERROR = 5
  39.     LOG_LEVEL_WARN = 4
  40.     LOG_LEVEL_INFO = 3
  41.     LOG_LEVEL_DEBUG = 2
  42.     LOG_LEVEL_DBG = 2
  43.  
  44.     logging_levels = {'none' : LOG_LEVEL_NONE,
  45.                        'fata' : LOG_LEVEL_FATAL,
  46.                        'fatal' : LOG_LEVEL_FATAL,
  47.                        'erro' : LOG_LEVEL_ERROR,
  48.                        'error' : LOG_LEVEL_ERROR,
  49.                        'warn' : LOG_LEVEL_WARN,
  50.                        'info' : LOG_LEVEL_INFO,
  51.                        'debu' : LOG_LEVEL_DEBUG,
  52.                        'debug' : LOG_LEVEL_DEBUG}
  53.  
  54.  
  55.     LOG_TO_DEV_NULL = 0
  56.     LOG_TO_CONSOLE = 1
  57.     LOG_TO_SCREEN = 1
  58.     LOG_TO_FILE = 2
  59.     LOG_TO_CONSOLE_AND_FILE = 3
  60.     LOG_TO_BOTH = 3
  61.  
  62.  
  63.     def __init__(self, module='', level=LOG_LEVEL_INFO, where=LOG_TO_CONSOLE_AND_FILE,
  64.                  log_datetime=False, log_file=None):
  65.  
  66.         self.set_level(level)
  67.         self._where = where
  68.         self._log_file = log_file
  69.         self._log_datetime = log_datetime
  70.         self._lock = thread.allocate_lock()
  71.         self.module = module
  72.         self.pid = os.getpid()
  73.  
  74.     def set_level(self, level):
  75.         if isinstance(level,str):
  76.             level = level[:4].lower()
  77.  
  78.             if level in Logger.logging_levels.keys():
  79.                 self._level = Logger.logging_levels.get(level, Logger.LOG_LEVEL_INFO)
  80.                 return True
  81.             else:
  82.                 self.error("Invalid logging level: %s" % level)
  83.                 return False
  84.  
  85.         elif isinstance(level,int):
  86.             if Logger.LOG_LEVEL_DEBUG <= level <= Logger.LOG_LEVEL_FATAL:
  87.                 self._level = level
  88.             else:
  89.                 self.error("Invalid logging level: %d" % level)
  90.                 return False
  91.  
  92.         else:
  93.             return False
  94.  
  95.     def set_module(self, module):
  96.         self.module = module
  97.  
  98.  
  99.     def set_logfile(self, log_file):
  100.         self._log_file = log_file
  101.         try:
  102.             self._log_file_f = file(self._log_file, 'w')
  103.         except IOError:
  104.             self._log_file = None
  105.  
  106.     def set_where(self, where):
  107.         self._where = where
  108.  
  109.     def get_level(self):
  110.         return self._level
  111.  
  112.     def is_debug(self):
  113.         return self._level == Logger.LOG_LEVEL_DEBUG
  114.  
  115.     level = property(get_level, set_level)
  116.  
  117.  
  118.     def log(self, message, level):
  119.         if self._where in (Logger.LOG_TO_CONSOLE, Logger.LOG_TO_CONSOLE_AND_FILE):
  120.             try:
  121.                 self._lock.acquire()
  122.                 if level >= Logger.LOG_LEVEL_WARN:
  123.                     out = sys.stderr
  124.                 else:
  125.                     out = sys.stdout
  126.                 out.write(message)
  127.                 out.write('\n')
  128.             finally:
  129.                 self._lock.release()
  130.  
  131.         if self._log_file is not None and \
  132.             self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  133.  
  134.             try:
  135.                 self._lock.acquire()
  136.                 #self._log_file_f.write(printable(message))
  137.                 self._log_file_f.write(message.replace('\x1b', ''))
  138.                 self._log_file_f.write('\n')
  139.  
  140.             finally:
  141.                 self._lock.release()
  142.  
  143.  
  144.     def stderr(self, message):
  145.         try:
  146.             self._lock.acquire()
  147.             sys.stderr.write("%s: %s\n" % (self.module, message))
  148.         finally:
  149.             self._lock.release()
  150.  
  151.     def debug(self, message, fmt=True):
  152.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  153.             if fmt:
  154.                 self.log("%s%s[%d]: debug: %s%s" % ('\x1b[34;01m', self.module, self.pid, message, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  155.             else:
  156.                 self.log("%s[%d]: debug: %s" % (self.module, self.pid, message), Logger.LOG_LEVEL_DEBUG)
  157.  
  158.             syslog.syslog(syslog.LOG_DEBUG, "%s[%d]: debug: %s" % (self.module, self.pid, message))
  159.  
  160.     dbg = debug
  161.  
  162.     def debug_block(self, title, block, fmt=False):
  163.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  164.             if fmt:
  165.                 self.log("%s%s[%d]: debug: %s:%s" % ('\x1b[34;01m', self.module,  self.pid, title, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  166.                 self.log("%s%s%s" % ('\x1b[34;01m', block, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  167.             else:
  168.                 self.log("%s[%d]: debug: :%s" % (self.module, self.pid, title), Logger.LOG_LEVEL_DEBUG)
  169.                 self.log(block, Logger.LOG_LEVEL_DEBUG)
  170.  
  171.  
  172.     printable = """ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~  """
  173.  
  174.     def log_data(self, data, width=16, fmt=False):
  175.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  176.             index, line = 0, data[0:width]
  177.             while line:
  178.                 txt = ' '.join(['%04x: ' % index, ' '.join(['%02x' % ord(d) for d in line]), ' '*(width*3-3*len(line)), ''.join([('.', i)[i in Logger.printable] for i in line])])
  179.                 if fmt:
  180.                     self.log("%s%s[%d]: debug: %s:%s" % ('\x1b[34;01m', self.module,  self.pid, txt, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  181.                 else:
  182.                     self.log("%s[%d]: debug: :%s" % (self.module, self.pid, txt), Logger.LOG_LEVEL_DEBUG)
  183.  
  184.                 index += width
  185.                 line = data[index:index+width]                
  186.  
  187.     def info(self, message, fmt=True):
  188.         if self._level <= Logger.LOG_LEVEL_INFO:
  189.             self.log(message, Logger.LOG_LEVEL_INFO)
  190.  
  191.     information = info
  192.  
  193.     def warn(self, message, fmt=True):
  194.         if self._level <= Logger.LOG_LEVEL_WARN:
  195.             if fmt:
  196.                 self.log("%swarning: %s%s" % ('\x1b[35;06m', message, '\x1b[0m'), Logger.LOG_LEVEL_WARN)
  197.             else:
  198.                 self.log("warning: %s" % message, Logger.LOG_LEVEL_WARN)
  199.  
  200.             syslog.syslog(syslog.LOG_WARNING, "%s[%d]: warning: %s" % (self.module, self.pid, message))
  201.  
  202.     warning = warn
  203.  
  204.     def note(self, message, fmt=True):
  205.         if self._level <= Logger.LOG_LEVEL_WARN:
  206.             if fmt:
  207.                 self.log("%snote: %s%s" % ('\x1b[32;01m', message, '\x1b[0m'), Logger.LOG_LEVEL_WARN)
  208.             else:
  209.                 self.log("note: %s" % message, Logger.LOG_LEVEL_WARN)
  210.  
  211.             syslog.syslog(syslog.LOG_WARNING, "%s[%d]: note: %s" % (self.module, self.pid, message))
  212.  
  213.     notice = note
  214.  
  215.     def error(self, message, fmt=True):
  216.         if self._level <= Logger.LOG_LEVEL_ERROR:
  217.             if fmt:
  218.                 self.log("%serror: %s%s" % ('\x1b[31;01m', message, '\x1b[0m'), Logger.LOG_LEVEL_ERROR)
  219.             else:
  220.                 self.log("error: %s" % message, Logger.LOG_LEVEL_ERROR)
  221.  
  222.             syslog.syslog(syslog.LOG_ALERT, "%s[%d] error: %s" % (self.module, self.pid, message))
  223.  
  224.     def fatal(self, message, fmt=True):
  225.         if self._level <= Logger.LOG_LEVEL_FATAL:
  226.             if fmt:
  227.                 self.log("%sfatal error: %s%s" % ('\x1b[31;01m', message, '\x1b[0m'), Logger.LOG_LEVEL_DEBUG)
  228.             else:
  229.                 self.log("fatal error: %s" % message, Logger.LOG_LEVEL_DEBUG)
  230.  
  231.             syslog.syslog(syslog.LOG_ALERT, "%s[%d]: fatal: %s" % (self.module, self.pid, message))
  232.  
  233.     def exception(self):
  234.         typ, value, tb = sys.exc_info()
  235.         body = "Traceback (innermost last):\n"
  236.         lst = traceback.format_tb(tb) + traceback.format_exception_only(typ, value)
  237.         body = body + "%-20s %s" % (''.join(lst[:-1]), lst[-1],)
  238.         self.fatal(body)
  239.