libtuer.py

   1 import logging, logging.handlers, os, time, queue, threading, subprocess
   2 import traceback, smtplib
   3 import email.mime.text, email.utils
   4
   5 # Logging configuration
   6 syslogLevel = logging.INFO
   7 mailLevel   = logging.CRITICAL # must be "larger" than syslog level!
   8 from config import mailAddress
   9 printLevel  = logging.DEBUG
  10
  11 # Mail logging handler
  12 def sendeMail(subject, text, receivers, sender='sphinx@hacksaar.de', replyTo=None):
  13         assert isinstance(receivers, list)
  14         if not len(receivers): return # nothing to do
  15         # construct content
  16         msg = email.mime.text.MIMEText(text.encode('UTF-8'), 'plain', 'UTF-8')
  17         msg['Subject'] = subject
  18         msg['Date'] = email.utils.formatdate(localtime=True)
  19         msg['From'] = sender
  20         msg['To'] = ', '.join(receivers)
  21         if replyTo is not None:
  22                 msg['Reply-To'] = replyTo
  23         # put into envelope and send
  24         s = smtplib.SMTP('localhost')
  25         s.sendmail(sender, receivers, msg.as_string())
  26         s.quit()
  27
  28 # logging function
  29 class Logger:
  30         def __init__ (self):
  31                 self.syslog = logging.getLogger("tuerd")
  32                 self.syslog.setLevel(logging.DEBUG)
  33                 self.syslog.addHandler(logging.handlers.SysLogHandler(address = '/dev/log',
  34                                                                                                                 facility = logging.handlers.SysLogHandler.LOG_LOCAL0))
  35
  36         def _log (self, lvl, what):
  37                 thestr = "%s[%d]: %s" % ("tuerd", os.getpid(), what)
  38                 # console log
  39                 if lvl >= printLevel:
  40                         print(thestr)
  41                 # syslog
  42                 if lvl >= syslogLevel:
  43                         self.syslog.log(lvl, thestr)
  44                 # mail log
  45                 if lvl >= mailLevel and mailAddress is not None:
  46                         sendeMail('Kritischer Türfehler', what, mailAddress)
  47
  48         def debug(self, what):
  49                 self._log(logging.DEBUG, what)
  50         def info(self, what):
  51                 self._log(logging.INFO, what)
  52         def warning(self, what):
  53                 self._log(logging.WARNING, what)
  54         def error(self, what):
  55                 self._log(logging.ERROR, what)
  56         def critical(self, what):
  57                 self._log(logging.CRITICAL, what)
  58
  59 logger = Logger()
  60
  61 # run a Python command asynchronously
  62 def fire_and_forget(f):
  63         def _fire_and_forget():
  64                 try:
  65                         f()
  66                 except Exception as e:
  67                         logger.critical("fire_and_forget: Got exception out of callback: %s" % str(e))
  68                         logger.debug(traceback.format_exc())
  69         t = threading.Thread(target=_fire_and_forget)
  70         t.start()
  71
  72 # run a command asynchronously and log the return value if not 0
  73 # prefix must be a string identifying the code position where the call came from
  74 def fire_and_forget_cmd (cmd, log_prefix):
  75         logger.debug("Firing and forgetting command from %s: %s" % (log_prefix,str(cmd)))
  76         def _fire_and_forget_cmd ():
  77                 with open("/dev/null", "w") as fnull:
  78                         retcode = subprocess.call(cmd, stdout=fnull, stderr=fnull)
  79                         if retcode is not 0:
  80                                 logger.error("%sReturn code %d at command: %s" % (log_prefix,retcode,str(cmd)))
  81         fire_and_forget(_fire_and_forget_cmd)
  82
  83 # Threaded callback class
  84 class ThreadFunction():
  85         _CALL = 0
  86         _TERM = 1
  87
  88         def __init__(self, f, name):
  89                 self.name = name
  90                 self._f = f
  91                 self._q = queue.Queue()
  92                 self._t = threading.Thread(target=self._thread_func)
  93                 self._t.start()
  94
  95         def _thread_func(self):
  96                 while True:
  97                         (cmd, data) = self._q.get()
  98                         # run command
  99                         if cmd == ThreadFunction._CALL:
 100                                 try:
 101                                         self._f(*data)
 102                                 except Exception as e:
 103                                         logger.critical("ThreadFunction: Got exception out of handler thread %s: %s" % (self.name, str(e)))
 104                                         logger.debug(traceback.format_exc())
 105                         elif cmd == ThreadFunction._TERM:
 106                                 assert data is None
 107                                 break
 108                         else:
 109                                 logger.error("ThreadFunction: Command %d does not exist" % cmd)
 110
 111         def __call__(self, *arg):
 112                 self._q.put((ThreadFunction._CALL, arg))
 113
 114         def stop(self):
 115                 # empty the queue
 116                 try:
 117                         while True:
 118                                 self._q.get_nowait()
 119                 except queue.Empty:
 120                         pass
 121                 # now wait till the job-in-progress is done
 122                 self._q.put((ThreadFunction._TERM, None))
 123                 self._t.join()
 124
 125 # Thread timer-repeater class: Call a function every <sleep_time> seconds
 126 class ThreadRepeater():
 127         def __init__(self, f, sleep_time, name):
 128                 self.name = name
 129                 self._f = f
 130                 self._stop = False
 131                 self._sleep_time = sleep_time
 132                 self._t = threading.Thread(target=self._thread_func)
 133                 self._t.start()
 134
 135         def _thread_func(self):
 136                 while True:
 137                         if self._stop:
 138                                 break
 139                         try:
 140                                 self._f()
 141                         except Exception as e:
 142                                 logger.critical("ThreadRepeater: Got exception out of handler thread %s: %s" % (self.name, str(e)))
 143                                 logger.debug(traceback.format_exc())
 144                         time.sleep(self._sleep_time)
 145
 146         def stop(self):
 147                 self._stop = True
 148                 self._t.join()