Fallback mode works now (software side)

[saartuer.git] / libtuer.py

diff --git a/libtuer.py b/libtuer.py
index e31ce2728497f1c2dab8bfadad7d3b7a153ec41c..835bf6d51003e22dd8a2d5e3b9ed72e85fae0577 100644 (file)
--- a/libtuer.py
+++ b/libtuer.py
@@ -1,50 +1,91 @@
-import logging, logging.handlers, os, time, queue, threading, subprocess, multiprocessing
+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):
 
 # 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):
        
        def debug(self, what):

-               self.log(logging.DEBUG, what)
+               self._log(logging.DEBUG, what)

        def info(self, what):
        def info(self, what):

-               self.log(logging.INFO, what)
+               self._log(logging.INFO, what)

        def warning(self, what):
        def warning(self, what):

-               self.log(logging.WARNING, what)
+               self._log(logging.WARNING, what)

        def error(self, what):
        def error(self, what):

-               self.log(logging.ERROR, what)
+               self._log(logging.ERROR, what)

        def critical(self, what):
        def critical(self, what):

-               self.log(logging.CRITICAL, what)
+               self._log(logging.CRITICAL, what)

 
 logger = Logger()
 
 
 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
 # 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 (cmd, log, prefix):
+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:
                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)))
-       p = multiprocessing.Process(target=_fire_and_forget, args=(cmd,log,prefix))
-       p.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
        
 
 # 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)
                self._f = f
                self._q = queue.Queue()
                self._t = threading.Thread(target=self._thread_func)


@@ -54,39 +95,45 @@ class ThreadFunction():
                while True:
                        (cmd, data) = self._q.get()
                        # run command
                while True:
                        (cmd, data) = self._q.get()
                        # run command

-                       if cmd == _CALL:
+                       if cmd == ThreadFunction._CALL:

                                try:
                                        self._f(*data)
                                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):
                                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):
        
        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():
                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()
        
                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
                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
        
        def stop(self):
                self._stop = True