mirror of
https://github.com/SickGear/SickGear.git
synced 2024-11-30 00:13:38 +00:00
151 lines
4.1 KiB
Python
151 lines
4.1 KiB
Python
import os
|
|
import sys
|
|
import time
|
|
import hachoir.core.config as config
|
|
|
|
|
|
class Log:
|
|
LOG_INFO = 0
|
|
LOG_WARN = 1
|
|
LOG_ERROR = 2
|
|
|
|
level_name = {
|
|
LOG_WARN: "[warn]",
|
|
LOG_ERROR: "[err!]",
|
|
LOG_INFO: "[info]"
|
|
}
|
|
|
|
def __init__(self):
|
|
self.__buffer = {}
|
|
self.__file = None
|
|
self.use_print = True
|
|
self.use_buffer = False
|
|
# Prototype: def func(level, prefix, text, context)
|
|
self.on_new_message = None
|
|
|
|
def shutdown(self):
|
|
if self.__file:
|
|
self._writeIntoFile("Stop Hachoir")
|
|
|
|
def setFilename(self, filename, append=True):
|
|
"""
|
|
Use a file to store all messages. The
|
|
UTF-8 encoding will be used. Write an informative
|
|
message if the file can't be created.
|
|
|
|
@param filename: C{L{string}}
|
|
"""
|
|
|
|
# Look if file already exists or not
|
|
filename = os.path.expanduser(filename)
|
|
filename = os.path.realpath(filename)
|
|
append = os.access(filename, os.F_OK)
|
|
|
|
# Create log file (or open it in append mode, if it already exists)
|
|
try:
|
|
import codecs
|
|
if append:
|
|
self.__file = codecs.open(filename, "a", "utf-8")
|
|
else:
|
|
self.__file = codecs.open(filename, "w", "utf-8")
|
|
self._writeIntoFile("Starting Hachoir")
|
|
except FileNotFoundError:
|
|
self.__file = None
|
|
self.info("[Log] setFilename(%s) fails: no such file"
|
|
% filename)
|
|
|
|
def _writeIntoFile(self, message):
|
|
timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
self.__file.write("%s - %s\n" % (timestamp, message))
|
|
self.__file.flush()
|
|
|
|
def newMessage(self, level, text, ctxt=None):
|
|
"""
|
|
Write a new message : append it in the buffer,
|
|
display it to the screen (if needed), and write
|
|
it in the log file (if needed).
|
|
|
|
@param level: Message level.
|
|
@type level: C{int}
|
|
@param text: Message content.
|
|
@type text: C{str}
|
|
@param ctxt: The caller instance.
|
|
"""
|
|
|
|
if level < self.LOG_ERROR and config.quiet or \
|
|
level <= self.LOG_INFO and not config.verbose:
|
|
return
|
|
if config.debug:
|
|
from hachoir.core.error import getBacktrace
|
|
backtrace = getBacktrace(None)
|
|
if backtrace:
|
|
text += "\n\n" + backtrace
|
|
|
|
_text = text
|
|
if hasattr(ctxt, "_logger"):
|
|
_ctxt = ctxt._logger()
|
|
if _ctxt is not None:
|
|
text = "[%s] %s" % (_ctxt, text)
|
|
|
|
# Add message to log buffer
|
|
if self.use_buffer:
|
|
if level not in self.__buffer:
|
|
self.__buffer[level] = [text]
|
|
else:
|
|
self.__buffer[level].append(text)
|
|
|
|
# Add prefix
|
|
prefix = self.level_name.get(level, "[info]")
|
|
|
|
# Display on stdout (if used)
|
|
if self.use_print:
|
|
sys.stdout.flush()
|
|
sys.stderr.write("%s %s\n" % (prefix, text))
|
|
sys.stderr.flush()
|
|
|
|
# Write into outfile (if used)
|
|
if self.__file:
|
|
self._writeIntoFile("%s %s" % (prefix, text))
|
|
|
|
# Use callback (if used)
|
|
if self.on_new_message:
|
|
self.on_new_message(level, prefix, _text, ctxt)
|
|
|
|
def info(self, text):
|
|
"""
|
|
New informative message.
|
|
@type text: C{str}
|
|
"""
|
|
self.newMessage(Log.LOG_INFO, text)
|
|
|
|
def warning(self, text):
|
|
"""
|
|
New warning message.
|
|
@type text: C{str}
|
|
"""
|
|
self.newMessage(Log.LOG_WARN, text)
|
|
|
|
def error(self, text):
|
|
"""
|
|
New error message.
|
|
@type text: C{str}
|
|
"""
|
|
self.newMessage(Log.LOG_ERROR, text)
|
|
|
|
|
|
log = Log()
|
|
|
|
|
|
class Logger(object):
|
|
|
|
def _logger(self):
|
|
return "<%s>" % self.__class__.__name__
|
|
|
|
def info(self, text):
|
|
log.newMessage(Log.LOG_INFO, text, self)
|
|
|
|
def warning(self, text):
|
|
log.newMessage(Log.LOG_WARN, text, self)
|
|
|
|
def error(self, text):
|
|
log.newMessage(Log.LOG_ERROR, text, self)
|