import logging, logging.handlers, os, time, queue, threading, subprocess
+import traceback, smtplib
+import email.mime.text, email.utils
+
+# Logging configuration
+syslogLevel = logging.INFO
+mailLevel = logging.CRITICAL # must be "larger" than syslog level!
+mailAddress = ['post+tuer'+'@'+'ralfj.de', 'vorstand@lists.hacksaar.de']
+printLevel = logging.DEBUG
+
+# Mail logging handler
+def sendeMail(subject, text, receivers, sender='sphinx@hacksaar.de', replyTo=None):
+ assert isinstance(receivers, list)
+ if not len(receivers): return # nothing to do
+ # construct content
+ msg = email.mime.text.MIMEText(text.encode('UTF-8'), 'plain', 'UTF-8')
+ msg['Subject'] = subject
+ msg['Date'] = email.utils.formatdate(localtime=True)
+ msg['From'] = sender
+ msg['To'] = ', '.join(receivers)
+ if replyTo is not None:
+ msg['Reply-To'] = replyTo
+ # put into envelope and send
+ s = smtplib.SMTP('localhost')
+ s.sendmail(sender, receivers, msg.as_string())
+ s.quit()
# logging function
class Logger:
def __init__ (self):
- import __main__ as main
- self.name = os.path.basename(main.__file__)
- self.logger = logging.getLogger(self.name)
- self.logger.setLevel(logging.INFO)
- self.handler = logging.handlers.SysLogHandler(address = '/dev/log', facility = logging.handlers.SysLogHandler.LOG_LOCAL0)
- self.logger.addHandler(self.handler)
+ self.syslog = logging.getLogger("tuerd")
+ self.syslog.setLevel(logging.DEBUG)
+ self.syslog.addHandler(logging.handlers.SysLogHandler(address = '/dev/log',
+ facility = logging.handlers.SysLogHandler.LOG_LOCAL0))
- def log (self, lvl, what):
- thestr = "%s[%d]: %s" % (self.name,os.getpid(),what)
- print (thestr)
- self.logger.log(lvl, thestr)
+ def _log (self, lvl, what):
+ thestr = "%s[%d]: %s" % ("tuerd", os.getpid(), what)
+ # console log
+ if lvl >= printLevel:
+ print(thestr)
+ # syslog
+ if lvl >= syslogLevel:
+ self.syslog.log(lvl, thestr)
+ # mail log
+ if lvl >= mailLevel and mailAddress is not None:
+ sendeMail('Kritischer Türfehler', what, mailAddress)
def debug(self, what):
- self.log(logging.DEBUG, what)
+ self._log(logging.DEBUG, what)
def info(self, what):
- self.log(logging.INFO, what)
+ self._log(logging.INFO, what)
def warning(self, what):
- self.log(logging.WARNING, what)
+ self._log(logging.WARNING, what)
def error(self, what):
- self.log(logging.ERROR, what)
+ self._log(logging.ERROR, what)
def critical(self, what):
- self.log(logging.CRITICAL, what)
+ self._log(logging.CRITICAL, what)
logger = Logger()
+# run a Python command asynchronously
+def fire_and_forget(f):
+ def _fire_and_forget():
+ try:
+ f()
+ except Exception as e:
+ logger.critical("fire_and_forget: Got exception out of callback: %s" % str(e))
+ logger.debug(traceback.format_exc())
+ t = threading.Thread(target=_fire_and_forget)
+ t.start()
+
# run a command asynchronously and log the return value if not 0
# prefix must be a string identifying the code position where the call came from
-def fire_and_forget (cmd, log, prefix):
- def _fire_and_forget ():
+def fire_and_forget_cmd (cmd, log, prefix):
+ def _fire_and_forget_cmd ():
with open("/dev/null", "w") as fnull:
retcode = subprocess.call(cmd, stdout=fnull, stderr=fnull)
if retcode is not 0:
- log("%sReturn code %d at command: %s" % (prefix,retcode,str(cmd)))
- t = threading.Thread(target=_fire_and_forget)
- t.start()
+ logger.error("%sReturn code %d at command: %s" % (prefix,retcode,str(cmd)))
+ fire_and_forget(_fire_and_forget_cmd)
# Threaded callback class
class ThreadFunction():
_CALL = 0
_TERM = 1
- def __init__(self, f):
+ def __init__(self, f, name):
+ self.name = name
self._f = f
self._q = queue.Queue()
self._t = threading.Thread(target=self._thread_func)
while True:
(cmd, data) = self._q.get()
# run command
- if cmd == _CALL:
+ if cmd == ThreadFunction._CALL:
try:
self._f(*data)
- except Exception:
- logger.error("ThreadFunction: Got exception out of handler thread: %s" % str(e))
- elif cmd == _TERM:
+ except Exception as e:
+ logger.critical("ThreadFunction: Got exception out of handler thread %s: %s" % (self.name, str(e)))
+ logger.debug(traceback.format_exc())
+ elif cmd == ThreadFunction._TERM:
assert data is None
break
else:
logger.error("ThreadFunction: Command %d does not exist" % cmd)
def __call__(self, *arg):
- self._q.put((self._CALL, arg))
+ self._q.put((ThreadFunction._CALL, arg))
def stop(self):
- self._q.put((_TERM, None))
+ self._q.put((ThreadFunction._TERM, None))
self._t.join()
# Thread timer-repeater class: Call a function every <sleep_time> seconds
class ThreadRepeater():
- def __init__(self, f, sleep_time):
+ def __init__(self, f, sleep_time, name):
+ self.name = name
self._f = f
self._stop = False
self._sleep_time = sleep_time
self._t = threading.Thread(target=self._thread_func)
self._t.start()
- def _thread_func():
+ def _thread_func(self):
while True:
if self._stop:
break
- self._f()
- time.sleep(sleep_time)
+ try:
+ self._f()
+ except Exception as e:
+ logger.critical("ThreadRepeater: Got exception out of handler thread %s: %s" % (self.name, str(e)))
+ logger.debug(traceback.format_exc())
+ time.sleep(self._sleep_time)
def stop(self):
self._stop = True
projects / saartuer.git / blobdiff