WireGate.py

#!/usr/bin/env python
# -*- coding: iso8859-1 -*-
## -----------------------------------------------------
## WireGate.py
## -----------------------------------------------------
## Copyright (c) 2010, knx-user-forum e.V, All rights reserved.
##
## This program is free software; you can redistribute it and/or modify it under the terms
## of the GNU General Public License as published by the Free Software Foundation; either
## version 3 of the License, or (at your option) any later version.
##
## This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
## without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
## See the GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License along with this program;
## if not, see <http://www.gnu.de/documents/gpl-3.0.de.html>.

import sys
import os
import time
import signal
import traceback
import daemon
import log 
import re
import threading

import ConfigParser

import datastore
import scheduler


class WireGate(daemon.Daemon):
    def __init__(self,REDIRECTIO=False):
        self._parent = self
        self.WG = self
        self.watchdoglist = {}
        self.connectors = {}
        self.LOGGER = {}
        self.LoggerCreateLock = threading.RLock()
        
        self.REDIRECTIO = REDIRECTIO
        
        ## Get the path of this script
        self.scriptpath = re.findall("from \x27(.*)\x2F",str(datastore))[0]

        self.readWireGateConfig()

        self.ErrorLOGGER = self.__createLog("WireGateErr",filename=self.config['WireGate']['errorlog'],maxlevel='error')
        
        ## Start the Datastore
        self.DATASTORE = datastore.datastore(self)
        
        ## Start the Daemon
        daemon.Daemon.__init__(self,self.config['WireGate']['pidfile'],REDIRECTIO)



    def readWireGateConfig(self):
        self.config = self.readConfig("/etc/wiregate/pywiregate.conf")
        defaultconfig = {
            'pidfile' : "%s/wiregated.pid" % self.scriptpath,
            'datastore' : "%s/datastore.db" % self.scriptpath,
            'logfile' : "%s/wiregated.log" % self.scriptpath,
            'errorlog' : "%s/wiregated-error.log" % self.scriptpath,
            'loglevel': 'info',
            'defaultencoding': 'iso-8859-15'
        }
        
        self.checkconfig("WireGate",defaultconfig)
        ## Remove this later
        if "plugins" in self.config['WireGate']:
            self.log("old Config",'critical')
        


    def checkconfig(self,instance,defaults):
        if instance not in self.config:
            self.config[instance] = defaults
            return
        for cfg in defaults:
            if cfg not in self.config[instance]:
                self.config[instance][cfg] = defaults[cfg]


    def readConfig(self,configfile):
        config = {}
        configparse = ConfigParser.SafeConfigParser()
        configparse.readfp(open(configfile))
        for section in configparse.sections():
            options = configparse.options(section)
            config[section] = {}
            for opt in options:
                try:
                    config[section][opt] = configparse.getint(section,opt)
                except ValueError:
                    try:
                        config[section][opt] = configparse.getfloat(section,opt)
                    except ValueError:
                        config[section][opt] = configparse.get(section,opt)
        
        return config




    def isdaemon(self):
        ## Called when in Daemon state
        signal.signal(signal.SIGTERM,self._signalhandler)
        signal.signal(signal.SIGHUP,self._signalhandler)

    def _signalhandler(self,signum,frame):
        if signum == signal.SIGHUP:
            self.debug("LOGROTATE")
        elif signum == signal.SIGTERM:
            sys.exit(1)
        else:
            self.debug("Unknown Signal: %d  " % signum)


    def run(self):
        for configpart in self.config.keys():
            if "connector" in self.config[configpart]:
                name = configpart
                connector = self.config[configpart]['connector']
            else:
                ## no connector in Section
                continue
            try:
                if len(connector)>0:
                    ## Import Connector
                    try:
                        exec("import %s" % connector)
                    except:
                        self.WG.errorlog(connector)
                        self.log("unknown connector: %s" % connector,'error')
                        continue
                    ## Load the Connector
                    exec("self.connectors['%s'] = %s.%s(self,name)" % (name,connector,connector))
            except:
                self.WG.errorlog(connector)
                pass
        
        ## Start the Sheduler
        self.SCHEDULER = scheduler.scheduler(self)
        self.SCHEDULER.start()

        if os.getuid() == 0:
            import pwd
            startuser=pwd.getpwuid(os.getuid())
            try:
                runasuser=pwd.getpwnam(self.config['WireGate']['user'])
                getpath = lambda x: "/".join(x.split("/")[:-1])
                        
                ##Set Permissions on 
                for sysfile in [self.config['WireGate']['pidfile'],self.config['WireGate']['logfile'],self.config['WireGate']['datastore']]:
                    if not os.path.exists(sysfile):
                        open(sysfile,'w').close()
                    os.chown(sysfile,runasuser[2],runasuser[3])
                
                
                ##removed until fixing permissions
                #os.setregid(runasuser[3],runasuser[3])
                #os.setreuid(runasuser[2],runasuser[2])
        
                self.log("Change User/Group from %s(%d) to %s(%d) FIXME: disabled" % (startuser[0],startuser[2],runasuser[0],runasuser[2]))
            
            except KeyError:
                pass
        if os.getuid() == 0:
            self.log("### Run as root is not recommend ### set user in pywiregate.conf",'warn')
        
        ## Mainloop only checking for Watchdog
        while True:
            time.sleep(5)
            self._checkwatchdog()


    ## always looping watchdog checker
    def _checkwatchdog(self):
        for obj in self.watchdoglist.keys():
            if time.time() > self.watchdoglist[obj]:
                    self.log("\n\nInstanz %s reagiert nicht\n\n" % obj,'error')
                    try:
                        self.connectors[obj].shutdown()
                    except:
                        pass
                    del self.watchdoglist[obj]
    
    ## set Watchdog
    def watchdog(self,instance,wtime):
        self.watchdoglist[instance] = time.time()+wtime


    def shutdown(self):
        #for dobj in self.DATASTORE.dataobjects.keys():
        #    print dobj+": "+str(self.DATASTORE.dataobjects[dobj].getValue())
        self.log("### Shutdown WireGated ###")
        
        self.SCHEDULER.shutdown()
        for instance in self.connectors.keys():
            try:
                self.connectors[instance].shutdown()
            except:
                pass
                
        ## now save Datastore
        self.DATASTORE.shutdown()

    
    ## Handle Errors
    def errorlog(self,msg=False):
        try:
            exc_type, exc_value, exc_traceback = sys.exc_info()
            tback = traceback.extract_tb(exc_traceback)
        except:
            exc_value = ""
            exc_type = ""
            tback = ""
            pass
        if msg:
            self.ErrorLOGGER.error(repr(msg))
        errmsg = "%r %r %r" % (exc_type, exc_value,tback)
        self.ErrorLOGGER.error(errmsg)
    

        
    ## TODO: Check COnfig for seperate Logfiles and min level for logging
    def createLog(self,instance):
        if instance in self.config:
            loglevel = self.config[instance].get('loglevel',False)
            filename = self.config[instance].get('logfile',False)
        else:
            loglevel = self.config['WireGate'].get('loglevel',False)
            filename = self.config['WireGate'].get('logfile',False)

        return self.__createLog(instance,filename=filename,maxlevel=loglevel)

    ## Create the Loginstance
    def __createLog(self,instance,filename=False,maxlevel=False):
        if not maxlevel:
            maxlevel = self.config['WireGate']['loglevel']
        if not filename:
            filename = self.config['WireGate']['logfile']
        LEVELS = {'debug': log.logging.DEBUG,'info': log.logging.INFO,'notice': log.logging.NOTICE,'warning': log.logging.WARNING,'error': log.logging.ERROR,'critical': log.logging.CRITICAL}
        level = LEVELS.get(maxlevel, log.logging.NOTSET)
        # create logger

        formatter = log.logging.Formatter('%(asctime)s %(name)-12s: %(levelname)-8s %(message)s')
        logger = log.logging.getLogger(instance)
        logger.setLevel(level)
        if filename:
            ## python handle logrotating
            handler = log.logging.handlers.TimedRotatingFileHandler(filename,'MIDNIGHT',encoding='UTF-8',backupCount=7)
            
            ## Handler if logrotate handles Logfiles
            #handler = logging.handlers.WatchedFileHandle(filename)
            handler.setFormatter(formatter)
            handler.setLevel(level)
            logger.addHandler(handler)


        # create console handler and set level to debug
        if self.REDIRECTIO:
            #console = logging.StreamHandler()
            console = log.isoStreamHandler()
            console.setFormatter(formatter)            
            logger.addHandler(console)
        return logger

    ## Logger for all instances that check/create logger based on Configfile
    def log(self,msg,severity="info",instance="WireGate"):
        try:
            self.LoggerCreateLock.acquire()
            try:
                logger = self.LOGGER[instance]
            except KeyError:
                logger = self.LOGGER[instance] = self.createLog(instance)
                pass
        finally:
            self.LoggerCreateLock.release()
        try:
            if severity=="debug":
                logger.debug(msg)
            elif severity=="info":
                logger.info(msg)
            elif severity=="notice":
                logger.notice(msg)
            elif severity=="warning":
                logger.warning(msg)
            elif severity=="warn":
                #print "SEVERITY: %r " % logging._levelNames

                logger.warning(msg)
            elif severity=="error":
                logger.error(msg)
            elif severity=="critical":
                logger.critical(msg)
            else:
                logger.info(msg)
        except:
            ## logging shouldnt break execution
            #pass
            raise


    def debug(self,msg):
        self.log(msg,"debug")

    ## Decouple from dir to avoid unmount troubles
    def decouple(self):
        os.chdir("/")
        os.umask(0)


if __name__ == "__main__":
    try:
        import os
        import sys
        import getopt
        try:
            opts, args = getopt.getopt(sys.argv[1:], "", ["start","stop","logrotate","nodaemon","stdout"])
        except getopt.GetoptError:
            print "Fehler"
            sys.exit(2)
        ACTION = ""
        RUNDAEMON = True
        REDIRECTIO = True
        for opt, arg in opts:
            if opt in ("--start"):
                ACTION = "start"
            if opt in ("--stop"):
                ACTION = "stop"
            if opt in ("--logrotate"):
                ACTION = "logrotate"
            if opt in ("--nodaemon"):
                RUNDAEMON = False
            if opt in ("--stdout"):
                REDIRECTIO = False


        WIREGATE = WireGate(REDIRECTIO)
        if ACTION == "start":
            WIREGATE.start(RUNDAEMON)
        elif ACTION == "stop":
            WIREGATE.stop()
        elif ACTION == "logrotate":
            WIREGATE.logrotate()
        else:
            print "--start oder --stop"
            sys.exit(1)
        if not RUNDAEMON:
            while True:
                pass
    except KeyboardInterrupt:
        pass
        print "Exiting"
        sys.exit(0)