def StartThreads(self, reload = False): try: # start thread to accept incoming sockets for nagios heartbeat self.Threads["ComWatchDog"] = MyThread(self.ComWatchDog, Name = "ComWatchDog") if self.bSyncDST or self.bSyncTime: # Sync time thread self.Threads["TimeSyncThread"] = MyThread(self.TimeSyncThread, Name = "TimeSyncThread") if not self.DisableWeather and not self.WeatherAPIKey == None and len(self.WeatherAPIKey) and not self.WeatherLocation == None and len(self.WeatherLocation): Unit = 'metric' if self.UseMetric else 'imperial' self.MyWeather = MyWeather(self.WeatherAPIKey, location = self.WeatherLocation, unit = Unit, log = self.log) self.Threads = self.MergeDicts(self.Threads, self.MyWeather.Threads) except Exception as e1: self.LogErrorLine("Error in StartThreads: " + str(e1))
def __init__(self, config=None, log=None, callback=None): super(MyMsgQueue, self).__init__() self.log = log self.config = config self.callback = callback self.MessageQueue = [] self.QueueLock = threading.RLock() self.max_retry_time = 600 # 10 min self.default_wait = 120 # 2 min self.debug = False if self.config != None: try: self.max_retry_time = self.config.ReadValue('max_retry_time', return_type=int, default=600) self.default_wait = self.config.ReadValue('default_wait', return_type=int, default=120) self.debug = self.config.ReadValue('debug', return_type=bool, default=False) except Exception as e1: self.LogErrorLine( "Error in MyMsgQueue:init, error reading config: " + str(e1)) if not self.callback == None: self.Threads["QueueWorker"] = MyThread(self.QueueWorker, Name="QueueWorker", start=False) self.Threads["QueueWorker"].Start()
def StartReadThread(self): # start read thread to monitor incoming data commands self.Threads["SerialReadThread"] = MyThread(self.ReadThread, Name="SerialReadThread") return self.Threads["SerialReadThread"]
def __init__(self, apikey, location, log = None, unit = 'imperial'): super(MyWeather, self).__init__() self.APIKey = apikey self.log = log self.Location = location self.OWM = None self.Observation = None self.WeatherUnit = unit self.WeatherData = None self.ObservationLocation = None self.DataAccessLock = threading.Lock() # lock to synchronize access to WeatherData if not pyowm_installed: self.LogError("Library pyowm not installed, disabling weather support." ) return try: if self.APIKey != None: self.APIKey = self.APIKey.strip() if self.Location != None: self.Location = self.Location.strip() if self.APIKey == None or not len(self.APIKey) or self.Location == None or not len(self.Location): self.LogError("Weather API key invalid or Weather Location invalid") return self.InitOWM() self.Threads["WeatherThread"] = MyThread(self.WeatherThread, Name = "WeatherThread") except Exception as e1: self.LogErrorLine("Error on MyWeather:init: " + str(e1))
def __init__(self, host="127.0.0.1", port=9082, log=None, callback=None, polltime=None, blacklist=None, flush_interval=float('inf'), use_numeric=False, debug=False): super(MyGenPush, self).__init__() self.Callback = callback self.UseNumeric = use_numeric self.Debug = debug if polltime == None: self.PollTime = 3 else: self.PollTime = float(polltime) if log != None: self.log = log else: # log errors in this module to a file self.log = SetupLogger("client", "/var/log/mygenpush.log") self.console = SetupLogger("mygenpush_console", log_file="", stream=True) self.AccessLock = threading.Lock() self.BlackList = blacklist self.LastValues = {} self.FlushInterval = flush_interval self.LastChange = {} try: startcount = 0 while startcount <= 10: try: self.Generator = ClientInterface(host=host, log=log) break except Exception as e1: startcount += 1 if startcount >= 10: self.console.info("genmon not loaded.") self.LogError("Unable to connect to genmon.") sys.exit(1) time.sleep(1) continue # start thread to accept incoming sockets for nagios heartbeat self.Threads["PollingThread"] = MyThread(self.MainPollingThread, Name="PollingThread") except Exception as e1: self.LogErrorLine("Error in mygenpush init: " + str(e1))
def __init__(self, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort, log = None, loglocation = ProgramDefaults.LogPath, onready = None, onexercise = None, onrun = None, onrunmanual = None, onalarm = None, onservice = None, onoff = None, onmanual = None, onutilitychange = None, start = True, console = None): super(GenNotify, self).__init__() self.AccessLock = threading.Lock() self.Threads = {} self.LastEvent = None self.LastOutageStatus = None self.Events = {} # Dict for handling events self.log = log self.console = console try: # init event callbacks if onready != None: self.Events["READY"] = onready if onexercise != None: self.Events["EXERCISING"] = onexercise if onrun != None: self.Events["RUNNING"] = onrun if onrunmanual != None: self.Events["RUNNING-MANUAL"] = onrunmanual if onalarm != None: self.Events["ALARM"] = onalarm if onservice != None: self.Events["SERVICEDUE"] = onservice if onoff != None: self.Events["OFF"] = onoff if onmanual != None: self.Events["MANUAL"] = onmanual if onutilitychange != None: self.Events["OUTAGE"] = onutilitychange self.Generator = ClientInterface(host = host, port = port, log = log, loglocation = loglocation) self.Threads["PollingThread"] = MyThread(self.MainPollingThread, Name = "PollingThread", start = start) self.Started = start except Exception as e1: self.LogErrorLine("Error in mynotify init: " + str(e1))
def __init__(self, updatecallback, address=0x9d, name="/dev/serial", rate=9600, config=None, inputfile=None): super(ModbusFile, self).__init__(updatecallback=updatecallback, address=address, name=name, rate=rate, config=config) self.Address = address self.Rate = rate self.PortName = name self.InputFile = inputfile self.InitComplete = False self.UpdateRegisterList = updatecallback self.RxPacketCount = 0 self.TxPacketCount = 0 self.ComTimoutError = 0 self.TotalElapsedPacketeTime = 0 self.ComTimoutError = 0 self.CrcError = 0 self.SimulateTime = True self.ModbusStartTime = datetime.datetime.now() # used for com metrics self.Registers = {} self.Strings = {} self.FileData = {} if self.InputFile == None: self.InputFile = os.path.dirname( os.path.realpath(__file__)) + "/modbusregs.txt" if not os.path.isfile(self.InputFile): self.LogError("Error: File not present: " + self.InputFile) self.CommAccessLock = threading.RLock( ) # lock to synchronize access to the serial port comms self.UpdateRegisterList = updatecallback if not self.ReadInputFile(self.InputFile): self.LogError("ModusFile Init(): Error loading input file: " + self.InputFile) else: if not self.AdjustInputData(): self.LogInfo("Error parsing input data") self.Threads["ReadInputFileThread"] = MyThread( self.ReadInputFileThread, Name="ReadInputFileThread", start=False) self.Threads["ReadInputFileThread"].Start() self.InitComplete = False
def __init__(self, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort, log=None, callback=None, polltime=None, blacklist=None, flush_interval=float('inf'), use_numeric=False, debug=False, loglocation=ProgramDefaults.LogPath, console=None): super(MyGenPush, self).__init__() self.Callback = callback self.UseNumeric = use_numeric self.debug = debug self.Exiting = False if polltime == None: self.PollTime = 3 else: self.PollTime = float(polltime) if log != None: self.log = log else: # log errors in this module to a file self.log = SetupLogger("client", os.path.join(loglocation, "mygenpush.log")) self.console = console self.AccessLock = threading.Lock() self.BlackList = blacklist self.LastValues = {} self.FlushInterval = flush_interval self.LastChange = {} try: self.Generator = ClientInterface(host=host, port=port, log=log) self.GetGeneratorStartInfo() # start thread to accept incoming sockets for nagios heartbeat self.Threads["MainPollingThread"] = MyThread( self.MainPollingThread, Name="MainPollingThread", start=False) self.Threads["MainPollingThread"].Start() except Exception as e1: self.LogErrorLine("Error in mygenpush init: " + str(e1))
def __init__(self, gpio=None, trigger=GPIO.FALLING, resistorpull=GPIO.PUD_UP, log=None, callback=None, uselibcallbacks=False, bouncetime=None): super(MyGPIOInput, self).__init__() self.Trigger = trigger self.ResistorPull = resistorpull self.GPIO = gpio self.log = log self.TimeoutSeconds = 1 self.BounceTime = bouncetime self.Callback = callback self.UseLibCallbacks = uselibcallbacks self.Exiting = False try: GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(True) GPIO.setup(gpio, GPIO.IN, pull_up_down=resistorpull) if callback != None and callable(callback): if self.BounceTime > 0: GPIO.add_event_detect(gpio=self.GPIO, edge=self.Trigger, bouncetime=self.BounceTime) else: GPIO.add_event_detect(gpio=self.GPIO, edge=self.Trigger) if self.UseLibCallbacks: GPIO.add_event_callback(gpio=self.GPIO, callback=self.Callback) else: # setup callback self.Threads["GPIOInputMonitor"] = MyThread( self.GPIOInputMonitor, Name="GPIOInputMonitor", start=False) self.Threads["GPIOInputMonitor"].Start() except Exception as e1: self.LogErrorLine("Error in MyGPIOInput:init: " + str(gpio) + " : " + str(e1))
def __init__(self, name, callback=None, Reuse=False, log=None, simulation=False, nullpipe=False, ConfigFilePath=ProgramDefaults.ConfPath): super(MyPipe, self).__init__(simulation=simulation) self.log = log self.BasePipeName = name self.NullPipe = nullpipe if self.Simulation: return self.ThreadName = "ReadPipeThread" + self.BasePipeName self.Callback = callback self.FileAccessLock = threading.RLock() self.FileName = os.path.join(ConfigFilePath, self.BasePipeName + "_dat") try: if not Reuse: try: os.remove(self.FileName) except: pass with open(self.FileName, 'w') as f: # create empty file f.write("") except Exception as e1: self.LogErrorLine("Error in MyPipe:__init__: " + str(e1)) if self.NullPipe or not self.Callback == None or not self.Simulation: self.Threads[self.ThreadName] = MyThread(self.ReadPipeThread, Name=self.ThreadName)
def __init__(self, log = None, loglocation = ProgramDefaults.LogPath, ConfigFilePath = MyCommon.DefaultConfPath, host = ProgramDefaults.LocalHost, port = ProgramDefaults.ServerPort, console = None): super(GenTankData, self).__init__() self.LogFileName = os.path.join(loglocation, "gentankutil.log") self.AccessLock = threading.Lock() self.log = log self.console = console self.MonitorAddress = host self.PollTime = 2 self.TankID = "" self.debug = False configfile = os.path.join(ConfigFilePath, 'gentankutil.conf') try: if not os.path.isfile(configfile): self.LogConsole("Missing config file : " + configfile) self.LogError("Missing config file : " + configfile) sys.exit(1) self.config = MyConfig(filename = configfile, section = 'gentankutil', log = self.log) self.PollTime = self.config.ReadValue('poll_frequency', return_type = float, default = 60) self.debug = self.config.ReadValue('debug', return_type = bool, default = False) self.username = self.config.ReadValue('username', default = "") self.password = self.config.ReadValue('password', default = "") self.tank_name = self.config.ReadValue('tank_name', default = "") if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = ProgramDefaults.LocalHost except Exception as e1: self.LogErrorLine("Error reading " + configfile + ": " + str(e1)) self.LogConsole("Error reading " + configfile + ": " + str(e1)) sys.exit(1) if self.username == "" or self.username == None or self.password == "" or self.password == None: self.LogError("Invalid user name or password, exiting") sys.exit(1) try: self.Generator = ClientInterface(host = self.MonitorAddress, port = port, log = self.log) #if not self.CheckGeneratorRequirement(): # self.LogError("Requirements not met. Exiting.") # sys.exit(1) self.tank = tankutility(self.username, self.password, self.log, debug = self.debug) # start thread monitor time for exercise self.Threads["TankCheckThread"] = MyThread(self.TankCheckThread, Name = "TankCheckThread", start = False) self.Threads["TankCheckThread"].Start() signal.signal(signal.SIGTERM, self.SignalClose) signal.signal(signal.SIGINT, self.SignalClose) except Exception as e1: self.LogErrorLine("Error in GenTankData init: " + str(e1)) self.console.error("Error in GenTankData init: " + str(e1)) sys.exit(1)
def __init__(self, host="127.0.0.1", port=9082, log=None, onready=None, onexercise=None, onrun=None, onrunmanual=None, onalarm=None, onservice=None, onoff=None, onmanual=None, onutilitychange=None): super(GenNotify, self).__init__() self.AccessLock = threading.Lock() self.Threads = {} self.LastEvent = None self.LastOutageStatus = None self.Events = {} # Dict for handling events if log != None: self.log = log else: # log errors in this module to a file self.log = SetupLogger("client", "/var/log/myclient.log") self.console = SetupLogger("notify_console", log_file="", stream=True) try: # init event callbacks if onready != None: self.Events["READY"] = onready if onexercise != None: self.Events["EXERCISING"] = onexercise if onrun != None: self.Events["RUNNING"] = onrun if onrunmanual != None: self.Events["RUNNING-MANUAL"] = onrunmanual if onalarm != None: self.Events["ALARM"] = onalarm if onservice != None: self.Events["SERVICEDUE"] = onservice if onoff != None: self.Events["OFF"] = onoff if onmanual != None: self.Events["MANUAL"] = onmanual if onutilitychange != None: self.Events["OUTAGE"] = onutilitychange startcount = 0 while startcount <= 10: try: self.Generator = ClientInterface(host=host, log=log) break except Exception as e1: startcount += 1 if startcount >= 10: self.console.info("genmon not loaded.") sys.exit(1) time.sleep(1) continue # start thread to accept incoming sockets for nagios heartbeat self.Threads["PollingThread"] = MyThread(self.MainPollingThread, Name="PollingThread") except Exception as e1: self.LogErrorLine("Error in mynotify init: " + str(e1))
def __init__(self, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort, log=None, loglocation=ProgramDefaults.LogPath, onready=None, onexercise=None, onrun=None, onrunmanual=None, onalarm=None, onservice=None, onoff=None, onmanual=None, onutilitychange=None, onsoftwareupdate=None, onsystemhealth=None, onfuelstate=None, start=True, console=None, notify_outage=True, notify_error=True, notify_warning=True, notify_info=True, notify_sw_update=True, config=None): super(GenNotify, self).__init__() self.AccessLock = threading.Lock() self.Threads = {} self.LastEvent = None self.LastOutageStatus = None self.LastSoftwareUpdateStatus = None self.LastSystemHealth = None self.LastFuelWarningStatus = True self.Events = {} # Dict for handling events self.notify_outage = notify_outage self.notify_error = notify_error self.notify_warning = notify_warning self.notify_info = notify_info self.notify_sw_update = notify_sw_update self.config = config self.log = log self.console = console try: # get settings from config file if supplied if self.config != None: self.notify_outage = self.config.ReadValue('notify_outage', return_type=bool, default=True) self.notify_error = self.config.ReadValue('notify_error', return_type=bool, default=True) self.notify_warning = self.config.ReadValue('notify_warning', return_type=bool, default=True) self.notify_info = self.config.ReadValue('notify_info', return_type=bool, default=True) self.notify_sw_update = self.config.ReadValue( 'notify_sw_update', return_type=bool, default=True) # init event callbacks if onready != None and self.notify_info: self.Events["READY"] = onready if onexercise != None and self.notify_info: self.Events["EXERCISING"] = onexercise if onrun != None and self.notify_info: self.Events["RUNNING"] = onrun if onrunmanual != None and self.notify_info: self.Events["RUNNING-MANUAL"] = onrunmanual if onalarm != None and self.notify_error: self.Events["ALARM"] = onalarm if onservice != None and self.notify_warning: self.Events["SERVICEDUE"] = onservice if onoff != None and self.notify_info: self.Events["OFF"] = onoff if onmanual != None and self.notify_info: self.Events["MANUAL"] = onmanual if onutilitychange != None and self.notify_outage: self.Events["OUTAGE"] = onutilitychange if onsoftwareupdate != None and self.notify_sw_update: self.Events["SOFTWAREUPDATE"] = onsoftwareupdate if onsystemhealth != None: self.Events["SYSTEMHEALTH"] = onsystemhealth if onfuelstate != None and self.notify_warning: self.Events["FUELWARNING"] = onfuelstate self.Generator = ClientInterface(host=host, port=port, log=log, loglocation=loglocation) self.Threads["PollingThread"] = MyThread(self.MainPollingThread, Name="PollingThread", start=start) self.Started = start except Exception as e1: self.LogErrorLine("Error in mynotify init: " + str(e1))
def __init__(self, monitor=False, incoming_folder=None, processed_folder=None, incoming_callback=None, localinit=False, loglocation=ProgramDefaults.LogPath, ConfigFilePath="/etc/", log=None, start=True): self.Monitor = monitor # true if we receive IMAP email self.IncomingFolder = incoming_folder # folder to look for incoming email self.ProcessedFolder = processed_folder # folder to move mail to once processed self.IncomingCallback = incoming_callback # called back with mail subject as a parameter if ConfigFilePath == None or ConfigFilePath == "": self.ConfigFilePath = "/etc/" else: self.ConfigFilePath = ConfigFilePath self.Mailbox = 0 self.EmailSendQueue = [] # queue for email to send self.DisableEmail = False self.DisableIMAP = False self.DisableSNMP = False self.DisableSmtpAuth = False self.SSLEnabled = False self.TLSDisable = False self.UseBCC = False self.ExtendWait = 0 self.Threads = {} # Dict of mythread objects self.debug = False self.ModulePath = os.path.dirname( os.path.dirname(os.path.realpath(__file__))) # log errors in this module to a file if localinit == True: self.logfile = "mymail.log" self.configfile = "mymail.conf" else: self.logfile = os.path.join(loglocation, "mymail.log") self.configfile = os.path.join(self.ConfigFilePath, "mymail.conf") if log == None: self.log = SetupLogger("mymail", self.logfile) else: self.log = log # if mymail.conf is present attempt to copy it from the # main source directory if not os.path.isfile(self.configfile): if os.path.join(os.path.isfile(self.ModulePath, "mymail.conf")): copyfile(os.path.join(self.ModulePath, "mymail.conf"), self.configfile) else: self.LogError("Missing config file : " + self.configfile) sys.exit(1) self.config = MyConfig(filename=self.configfile, section="MyMail", log=self.log) self.GetConfig() if self.DisableEmail: self.DisableIMAP = True self.DisableSNMP = True self.Monitor = False if not len(self.SMTPServer): self.DisableSNMP = True if not len(self.IMAPServer): self.DisableIMAP = True self.Monitor = False atexit.register(self.Close) if not self.DisableEmail: if not self.DisableSMTP and self.SMTPServer != "": self.Threads["SendMailThread"] = MyThread( self.SendMailThread, Name="SendMailThread", start=start) else: self.LogError("SMTP disabled") if not self.DisableIMAP and self.Monitor and self.IMAPServer != "": # if True then we will have an IMAP monitor thread if incoming_callback and incoming_folder and processed_folder: self.Threads["EmailCommandThread"] = MyThread( self.EmailCommandThread, Name="EmailCommandThread", start=start) else: self.FatalError( "ERROR: incoming_callback, incoming_folder and processed_folder are required if receive IMAP is used" ) else: self.LogError("IMAP disabled")
def __init__(self, log=None, loglocation=ProgramDefaults.LogPath, ConfigFilePath=MyCommon.DefaultConfPath, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort, console=None): super(GenCTHat, self).__init__() #https://tutorials-raspberrypi.com/mcp3008-read-out-analog-signals-on-the-raspberry-pi/ #https://forums.raspberrypi.com/viewtopic.php?t=237182 self.LogFileName = os.path.join(loglocation, "gencthat.log") self.AccessLock = threading.Lock() self.log = log self.console = console self.MonitorAddress = host self.PollTime = 2 self.SampleTimeMS = 34 self.debug = False self.ConfigFileName = 'gencthat.conf' configfile = os.path.join(ConfigFilePath, self.ConfigFileName) try: if not os.path.isfile(configfile): self.LogConsole("Missing config file : " + configfile) self.LogError("Missing config file : " + configfile) sys.exit(1) self.config = MyConfig(filename=configfile, section='gencthat', log=self.log) self.Multiplier = self.config.ReadValue('multiplier', return_type=float, default=0.488) # this checks to see if an old version of the conf file is in use and replaces it if self.Multiplier == 0.218: self.ConfPath = os.path.join( os.path.dirname(os.path.realpath(__file__)), "conf") if os.path.isfile( os.path.join(self.ConfPath, self.ConfigFileName)): copyfile(os.path.join(self.ConfPath, self.ConfigFileName), configfile) self.LogError( "Copied " + os.path.join(self.ConfPath, self.ConfigFileName) + " to " + configfile) self.config = MyConfig(filename=configfile, section='gencthat', log=self.log) else: self.LogError( "Error: unable to find config file: " + os.path.join(self.ConfPath, self.ConfigFileName)) self.SampleTimeMS = self.config.ReadValue('sample_time_ms', return_type=int, default=34) self.Multiplier = self.config.ReadValue('multiplier', return_type=float, default=0.488) self.PollTime = self.config.ReadValue('poll_frequency', return_type=float, default=60) self.powerfactor = self.config.ReadValue('powerfactor', return_type=float, default=1.0) self.bus = self.config.ReadValue('bus', return_type=int, default=1) self.device = self.config.ReadValue('device', return_type=int, default=0) self.strict = self.config.ReadValue('strict', return_type=bool, default=False) self.singlelegthreshold = self.config.ReadValue( 'singlelegthreshold', return_type=float, default=0.6) self.debug = self.config.ReadValue('debug', return_type=bool, default=False) self.LogDebug("Multiplier: " + str(self.Multiplier)) if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = ProgramDefaults.LocalHost except Exception as e1: self.LogErrorLine("Error reading " + configfile + ": " + str(e1)) self.LogConsole("Error reading " + configfile + ": " + str(e1)) sys.exit(1) try: self.adc = MCP3008(bus=self.bus, device=self.device, log=self.log) self.adc.open() self.Generator = ClientInterface(host=self.MonitorAddress, port=port, log=self.log) #if not self.CheckGeneratorRequirement(): # self.LogError("Requirements not met. Exiting.") # sys.exit(1) # start thread monitor time for exercise self.Threads["SensorCheckThread"] = MyThread( self.SensorCheckThread, Name="SensorCheckThread", start=False) self.Threads["SensorCheckThread"].Start() signal.signal(signal.SIGTERM, self.SignalClose) signal.signal(signal.SIGINT, self.SignalClose) except Exception as e1: self.LogErrorLine("Error in GenCTHat init: " + str(e1)) self.console.error("Error in GenCTHat init: " + str(e1)) sys.exit(1)
def StartTimeThread(self): # This is done is a separate thread as not to block any return email processing # since we attempt to sync with generator time MyThread(self.Controller.SetGeneratorTimeDate, Name = "SetTimeThread") return "Time Set: Command Sent\n"
def __init__(self, ConfigFilePath = ProgramDefaults.ConfPath): super(Monitor, self).__init__() self.ProgramName = "Generator Monitor" self.Version = "Unknown" self.log = None self.IsStopping = False self.ProgramComplete = False if ConfigFilePath == None or ConfigFilePath == "": self.ConfigFilePath = ProgramDefaults.ConfPath else: self.ConfigFilePath = ConfigFilePath self.ConnectionList = [] # list of incoming connections for heartbeat # defautl values self.SiteName = "Home" self.ServerSocket = None self.ServerSocketPort = ProgramDefaults.ServerPort # server socket for nagios heartbeat and command/status self.IncomingEmailFolder = "Generator" self.ProcessedEmailFolder = "Generator/Processed" self.FeedbackLogFile = self.ConfigFilePath + "feedback.json" self.LogLocation = ProgramDefaults.LogPath self.LastLogFileSize = 0 self.NumberOfLogSizeErrors = 0 # set defaults for optional parameters self.NewInstall = False # True if newly installed or newly upgraded version self.FeedbackEnabled = False # True if sending autoated feedback on missing information self.FeedbackMessages = {} self.OneTimeMessages = {} self.MailInit = False # set to true once mail is init self.CommunicationsActive = False # Flag to let the heartbeat thread know we are communicating self.Controller = None self.ControllerSelected = None self.bDisablePlatformStats = False self.ReadOnlyEmailCommands = False self.SlowCPUOptimization = False # weather parameters self.WeatherAPIKey = None self.WeatherLocation = None self.UseMetric = False self.WeatherMinimum = True self.DisableWeather = False self.MyWeather = None # Time Sync Related Data self.bSyncTime = False # Sync gen to system time self.bSyncDST = False # sync time at DST change self.bDST = False # Daylight Savings Time active if True # simulation self.Simulation = False self.SimulationFile = None self.console = SetupLogger("genmon_console", log_file = "", stream = True) if os.geteuid() != 0: self.LogConsole("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'.") sys.exit(1) if not os.path.isfile(self.ConfigFilePath + 'genmon.conf'): self.LogConsole("Missing config file : " + self.ConfigFilePath + 'genmon.conf') sys.exit(1) if not os.path.isfile(self.ConfigFilePath + 'mymail.conf'): self.LogConsole("Missing config file : " + self.ConfigFilePath + 'mymail.conf') sys.exit(1) self.config = MyConfig(filename = self.ConfigFilePath + 'genmon.conf', section = "GenMon", log = self.console) # read config file if not self.GetConfig(): self.LogConsole("Failure in Monitor GetConfig") sys.exit(1) # log errors in this module to a file self.log = SetupLogger("genmon", self.LogLocation + "genmon.log") self.config.log = self.log if self.IsLoaded(): self.LogConsole("ERROR: genmon.py is already loaded.") self.LogError("ERROR: genmon.py is already loaded.") sys.exit(1) if self.NewInstall: self.LogError("New version detected: Old = %s, New = %s" % (self.Version, GENMON_VERSION)) self.Version = GENMON_VERSION self.ProgramStartTime = datetime.datetime.now() # used for com metrics self.LastSofwareUpdateCheck = datetime.datetime.now() atexit.register(self.Close) signal.signal(signal.SIGTERM, self.Close) signal.signal(signal.SIGINT, self.Close) # start thread to accept incoming sockets for nagios heartbeat and command / status clients self.Threads["InterfaceServerThread"] = MyThread(self.InterfaceServerThread, Name = "InterfaceServerThread") # init mail, start processing incoming email self.mail = MyMail(monitor=True, incoming_folder = self.IncomingEmailFolder, processed_folder =self.ProcessedEmailFolder,incoming_callback = self.ProcessCommand, loglocation = self.LogLocation, ConfigFilePath = ConfigFilePath) self.Threads = self.MergeDicts(self.Threads, self.mail.Threads) self.MailInit = True self.FeedbackPipe = MyPipe("Feedback", self.FeedbackReceiver, log = self.log, ConfigFilePath = self.ConfigFilePath) self.Threads = self.MergeDicts(self.Threads, self.FeedbackPipe.Threads) self.MessagePipe = MyPipe("Message", self.MessageReceiver, log = self.log, nullpipe = self.mail.DisableSNMP, ConfigFilePath = self.ConfigFilePath) self.Threads = self.MergeDicts(self.Threads, self.MessagePipe.Threads) try: #Starting device connection if self.Simulation: self.LogError("Simulation Running") if not self.ControllerSelected == None and len(self.ControllerSelected): self.LogError("Selected Controller: " + str(self.ControllerSelected)) else: self.ControllerSelected = "generac_evo_nexus" if self.ControllerSelected.lower() == "h_100" : self.Controller = HPanel(self.log, newinstall = self.NewInstall, simulation = self.Simulation, simulationfile = self.SimulationFile, message = self.MessagePipe, feedback = self.FeedbackPipe, config = self.config) else: self.Controller = Evolution(self.log, self.NewInstall, simulation = self.Simulation, simulationfile = self.SimulationFile, message = self.MessagePipe, feedback = self.FeedbackPipe, config = self.config) self.Threads = self.MergeDicts(self.Threads, self.Controller.Threads) except Exception as e1: self.LogErrorLine("Error opening controller device: " + str(e1)) sys.exit(1) self.StartThreads() self.ProcessFeedbackInfo() # send mail to tell we are starting self.MessagePipe.SendMessage("Generator Monitor Starting at " + self.SiteName, "Generator Monitor Starting at " + self.SiteName , msgtype = "info") self.LogError("GenMon Loaded for site: " + self.SiteName)
def __init__(self, log=None, loglocation=ProgramDefaults.LogPath, ConfigFilePath=MyCommon.DefaultConfPath, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort): super(GenTankData, self).__init__() self.LogFileName = os.path.join(loglocation, "gentankdiy.log") self.AccessLock = threading.Lock() # log errors in this module to a file self.log = SetupLogger("gentankdiy", self.LogFileName) self.console = SetupLogger("gentankdiy_console", log_file="", stream=True) self.MonitorAddress = host self.PollTime = 2 self.debug = False configfile = os.path.join(ConfigFilePath, 'gentankdiy.conf') try: if not os.path.isfile(configfile): self.LogConsole("Missing config file : " + configfile) self.LogError("Missing config file : " + configfile) sys.exit(1) self.config = MyConfig(filename=configfile, section='gentankdiy', log=self.log) self.PollTime = self.config.ReadValue('poll_frequency', return_type=float, default=60) self.debug = self.config.ReadValue('debug', return_type=bool, default=False) self.i2c_address = self.config.ReadValue('i2c_address', return_type=int, default=72) self.mv_per_step = self.config.ReadValue('mv_per_step', return_type=int, default=125) self.Multiplier = self.config.ReadValue( 'volts_to_percent_multiplier', return_type=float, default=20.0) # I2C channel 1 is connected to the GPIO pins self.i2c_channel = self.config.ReadValue('i2c_channel', return_type=int, default=1) if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = ProgramDefaults.LocalHost except Exception as e1: self.LogErrorLine("Error reading " + configfile + ": " + str(e1)) self.LogConsole("Error reading " + configfile + ": " + str(e1)) sys.exit(1) try: try: startcount = 0 while startcount <= 10: try: self.Generator = ClientInterface( host=self.MonitorAddress, port=port, log=self.log) break except Exception as e1: startcount += 1 if startcount >= 10: self.console.info("genmon not loaded.") self.LogError("Unable to connect to genmon.") sys.exit(1) time.sleep(1) continue except Exception as e1: self.LogErrorLine("Error in GenTankData init: " + str(e1)) # start thread monitor time for exercise self.Threads["TankCheckThread"] = MyThread(self.TankCheckThread, Name="TankCheckThread", start=False) if not self.InitADC(): self.LogError("InitADC failed, exiting") sys.exit(1) self.Threads["TankCheckThread"].Start() atexit.register(self.Close) signal.signal(signal.SIGTERM, self.Close) signal.signal(signal.SIGINT, self.Close) except Exception as e1: self.LogErrorLine("Error in GenTankData init: " + str(e1)) self.console.error("Error in GenTankData init: " + str(e1)) sys.exit(1)
def __init__(self, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort, log=None, loglocation=ProgramDefaults.LogPath, onready=None, onexercise=None, onrun=None, onrunmanual=None, onalarm=None, onservice=None, onoff=None, onmanual=None, onutilitychange=None, start=True): super(GenNotify, self).__init__() self.AccessLock = threading.Lock() self.Threads = {} self.LastEvent = None self.LastOutageStatus = None self.Events = {} # Dict for handling events if log != None: self.log = log else: # log errors in this module to a file self.log = SetupLogger("client", os.path.join(loglocation, "myclient.log")) self.console = SetupLogger("notify_console", log_file="", stream=True) try: # init event callbacks if onready != None: self.Events["READY"] = onready if onexercise != None: self.Events["EXERCISING"] = onexercise if onrun != None: self.Events["RUNNING"] = onrun if onrunmanual != None: self.Events["RUNNING-MANUAL"] = onrunmanual if onalarm != None: self.Events["ALARM"] = onalarm if onservice != None: self.Events["SERVICEDUE"] = onservice if onoff != None: self.Events["OFF"] = onoff if onmanual != None: self.Events["MANUAL"] = onmanual if onutilitychange != None: self.Events["OUTAGE"] = onutilitychange startcount = 0 while startcount <= 10: try: self.Generator = ClientInterface(host=host, port=port, log=log, loglocation=loglocation) break except Exception as e1: startcount += 1 if startcount >= 10: self.console.info("genmon not loaded.") sys.exit(1) time.sleep(1) continue self.Threads["PollingThread"] = MyThread(self.MainPollingThread, Name="PollingThread", start=start) self.Started = start except Exception as e1: self.LogErrorLine("Error in mynotify init: " + str(e1))
def __init__(self, log=None, loglocation=ProgramDefaults.LogPath, ConfigFilePath=MyCommon.DefaultConfPath, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort, console=None): super(GenTankData, self).__init__() self.LogFileName = os.path.join(loglocation, "gentankdiy.log") self.AccessLock = threading.Lock() self.log = log self.console = console self.MonitorAddress = host configfile = os.path.join(ConfigFilePath, 'gentankdiy.conf') try: if not os.path.isfile(configfile): self.LogConsole("Missing config file : " + configfile) self.LogError("Missing config file : " + configfile) sys.exit(1) self.config = MyConfig(filename=configfile, section='gentankdiy', log=self.log) self.gauge_type = self.config.ReadValue('gauge_type', return_type=int, default=1) if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = ProgramDefaults.LocalHost except Exception as e1: self.LogErrorLine("Error reading " + configfile + ": " + str(e1)) self.LogConsole("Error reading " + configfile + ": " + str(e1)) sys.exit(1) try: if self.gauge_type == 1: self.gauge = GaugeDIY1(self.config, log=self.log, console=self.console) elif self.gauge_type == 2: self.gauge = GaugeDIY2(self.config, log=self.log, console=self.console) else: self.LogError("Invalid guage type: " + str(self.gauge_type)) sys.exit(1) self.debug = self.gauge.debug self.Generator = ClientInterface(host=self.MonitorAddress, port=port, log=self.log) # start thread monitor time for exercise self.Threads["TankCheckThread"] = MyThread(self.TankCheckThread, Name="TankCheckThread", start=False) if not self.gauge.InitADC(): self.LogError("InitADC failed, exiting") sys.exit(1) self.Threads["TankCheckThread"].Start() signal.signal(signal.SIGTERM, self.SignalClose) signal.signal(signal.SIGINT, self.SignalClose) except Exception as e1: self.LogErrorLine("Error in GenTankData init: " + str(e1)) self.console.error("Error in GenTankData init: " + str(e1)) sys.exit(1)
def __init__(self, port = "/dev/ttyAMA0" , rate = 115200, loglocation = ProgramDefaults.LogPath, log = None, localinit = False, ConfigFilePath = ProgramDefaults.ConfPath, recipient = None): super(MyModem, self).__init__() self.MessagesSent = 0 self.Errors = 0 self.SendActive = False self.ModemLock = threading.RLock() self.Sending = False self.SendQueue = [] if ConfigFilePath == None: self.ConfigFilePath = ProgramDefaults.ConfPath else: self.ConfigFilePath = ConfigFilePath # log errors in this module to a file if localinit == True: self.configfile = "mymodem.conf" else: self.configfile = os.path.join(self.ConfigFilePath, "mymodem.conf") # log errors in this module to a file if log == None: self.log = SetupLogger("mymodem", os.path.join(loglocation, "mymodem.log")) else: self.log = log self.console = SetupLogger("mymodem_console", log_file = "", stream = True) try: self.config = MyConfig(filename = self.configfile, section = "MyModem", log = self.log) self.LogAtCommands = self.config.ReadValue('log_at_commands', return_type = bool, default = False) self.MessageLevel = self.config.ReadValue('message_level', default = 'error') self.Rate = self.config.ReadValue('rate', return_type = int, default = 115200) self.Port = self.config.ReadValue('port', default = "/dev/ttyAMA0") self.Recipient = self.config.ReadValue('recipient', default = recipient) self.ModemType = self.config.ReadValue('modem_type', default = "LTEPiHat") except Exception as e1: self.LogErrorLine("Error reading config file: " + str(e1)) self.LogConsole("Error reading config file: " + str(e1)) return if self.Recipient == None or not len(self.Recipient): self.LogErrorLine("Error invalid recipient") self.LogConsole("Error invalid recipient") if self.Port == None or not len(self.Port): self.LogErrorLine("Error invalid port") self.LogConsole("Error invalid port") return if self.Rate == None or self.Rate <= 0: self.LogErrorLine("Error invalid rate") self.LogConsole("Error invalid rate") return # rate * 10 bits then convert to MS self.CharacterTimeMS = (((1/ self.Rate) * 10) *1000) self.InitComplete = False try: self.SerialDevice = SerialDevice(port, rate = rate, log = self.log, loglocation = loglocation) self.Threads = self.MergeDicts(self.Threads, self.SerialDevice.Threads) self.Threads["SendMessageThread"] = MyThread(self.SendMessageThread, Name = "SendMessageThread") except Exception as e1: self.LogErrorLine("Error opening serial device in MyModem: " + str(e1))
def __init__(self, log=None, loglocation=ProgramDefaults.LogPath, ConfigFilePath=MyCommon.DefaultConfPath, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort, console=None): super(GenExercise, self).__init__() self.AccessLock = threading.Lock() self.log = log self.console = console self.MonitorAddress = host self.PollTime = 2 self.ExerciseActive = False self.Debug = False try: self.config = MyConfig(filename=os.path.join( ConfigFilePath, 'genexercise.conf'), section='genexercise', log=self.log) self.ExerciseType = self.config.ReadValue('exercise_type', default="Normal") self.ExerciseHour = self.config.ReadValue('exercise_hour', return_type=int, default=12) self.ExerciseMinute = self.config.ReadValue('exercise_minute', return_type=int, default=0) self.ExerciseDayOfMonth = self.config.ReadValue( 'exercise_day_of_month', return_type=int, default=1) self.ExerciseDayOfWeek = self.config.ReadValue( 'exercise_day_of_week', default="Monday") self.ExerciseDuration = self.config.ReadValue('exercise_duration', return_type=float, default=12) self.ExerciseWarmup = self.config.ReadValue('exercise_warmup', return_type=float, default=0) self.ExerciseFrequency = self.config.ReadValue( 'exercise_frequency', default="Monthly") self.MonitorAddress = self.config.ReadValue( 'monitor_address', default=ProgramDefaults.LocalHost) self.LastExerciseTime = self.config.ReadValue('last_exercise', default=None) self.UseGeneratorTime = self.config.ReadValue('use_gen_time', return_type=bool, default=False) self.Debug = self.config.ReadValue('debug', return_type=bool, default=False) # Validate settings if not self.ExerciseType.lower() in [ "normal", "quiet", "transfer" ]: self.ExerciseType = "normal" if self.ExerciseHour > 23 or self.ExerciseHour < 0: self.ExerciseHour = 12 if self.ExerciseMinute > 59 or self.ExerciseMinute < 0: self.ExerciseMinute = 0 if not self.ExerciseDayOfWeek.lower() in [ "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday" ]: self.ExerciseDayOfWeek = "Monday" if self.ExerciseDayOfMonth > 28 or self.ExerciseDayOfMonth < 1: self.ExerciseDayOfMonth = 1 if self.ExerciseDuration > 60: self.ExerciseDuration = 60 if self.ExerciseDuration < 5: self.ExerciseDuration = 5 if self.ExerciseWarmup > 30: self.ExerciseWarmup = 30 if self.ExerciseWarmup < 0: self.ExerciseWarmup = 0 if not self.ExerciseFrequency.lower() in [ "weekly", "biweekly", "monthly" ]: self.ExerciseFrequency = "Monthly" if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = ProgramDefaults.LocalHost except Exception as e1: self.LogErrorLine( "Error reading " + os.path.join(ConfigFilePath, "genexercise.conf") + ": " + str(e1)) self.console.error( "Error reading " + os.path.join(ConfigFilePath, "genexercise.conf") + ": " + str(e1)) sys.exit(1) try: self.Generator = ClientInterface(host=self.MonitorAddress, port=port, log=self.log) if not self.CheckGeneratorRequirement(): self.LogError("Requirements not met. Exiting.") sys.exit(1) # start thread monitor time for exercise self.Threads["ExerciseThread"] = MyThread(self.ExerciseThread, Name="ExerciseThread", start=False) self.Threads["ExerciseThread"].Start() try: if self.ExerciseFrequency.lower() == "monthly": DayStr = "Day " + str(self.ExerciseDayOfMonth) else: DayStr = str(self.ExerciseDayOfWeek) self.LogError("Execise: " + self.ExerciseType + ", " + self.ExerciseFrequency + " at " + str(self.ExerciseHour) + ":" + str(self.ExerciseMinute) + " on " + DayStr + " for " + str(self.ExerciseDuration) + " min. Warmup: " + str(self.ExerciseWarmup)) self.DebugOutput("Debug Enabled") except Exception as e1: self.LogErrorLine(str(e1)) signal.signal(signal.SIGTERM, self.SignalClose) signal.signal(signal.SIGINT, self.SignalClose) except Exception as e1: self.LogErrorLine("Error in GenExercise init: " + str(e1)) self.console.error("Error in GenExercise init: " + str(e1)) sys.exit(1)
def __init__(self, log=None, loglocation=ProgramDefaults.LogPath, ConfigFilePath=MyCommon.DefaultConfPath, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort): super(GenTemp, self).__init__() self.LogFileName = os.path.join(loglocation, "gentemp.log") self.AccessLock = threading.Lock() # log errors in this module to a file self.log = SetupLogger("gentemp", self.LogFileName) self.console = SetupLogger("gentemp_console", log_file="", stream=True) self.LastValues = {} self.MonitorAddress = host self.debug = False self.PollTime = 1 self.BlackList = None configfile = os.path.join(ConfigFilePath, 'gentemp.conf') try: if not os.path.isfile(configfile): self.LogConsole("Missing config file : " + configfile) self.LogError("Missing config file : " + configfile) sys.exit(1) self.config = MyConfig(filename=configfile, section='gentemp', log=self.log) self.UseMetric = self.config.ReadValue('use_metric', return_type=bool, default=False) self.PollTime = self.config.ReadValue('poll_frequency', return_type=float, default=1) self.debug = self.config.ReadValue('debug', return_type=bool, default=False) self.DeviceLabels = self.GetParamList( self.config.ReadValue('device_labels', default=None)) self.BlackList = self.GetParamList( self.config.ReadValue('blacklist', default=None)) if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = ProgramDefaults.LocalHost except Exception as e1: self.LogErrorLine("Error reading " + configfile + ": " + str(e1)) self.LogConsole("Error reading " + configfile + ": " + str(e1)) sys.exit(1) try: try: startcount = 0 while startcount <= 10: try: self.Generator = ClientInterface( host=self.MonitorAddress, port=port, log=self.log) break except Exception as e1: startcount += 1 if startcount >= 10: self.LogConsole("genmon not loaded.") self.LogError("Unable to connect to genmon.") sys.exit(1) time.sleep(1) continue except Exception as e1: self.LogErrorLine("Error in GenTempThread init: " + str(e1)) self.DeviceList = self.EnumDevices() if not len(self.DeviceList): self.LogConsole("No sensors found.") self.LogError("No sensors found.") sys.exit(1) # start thread monitor time for exercise self.Threads["GenTempThread"] = MyThread(self.GenTempThread, Name="GenTempThread", start=False) self.Threads["GenTempThread"].Start() atexit.register(self.Close) except Exception as e1: self.LogErrorLine("Error in GenTemp init: " + str(e1)) self.LogConsole("Error in GenTemp init: " + str(e1)) sys.exit(1)
def __init__(self, log=None, loglocation=ProgramDefaults.LogPath, ConfigFilePath=MyCommon.DefaultConfPath, host=ProgramDefaults.LocalHost, port=ProgramDefaults.ServerPort): super(GenTankData, self).__init__() self.LogFileName = loglocation + "gentankutil.log" self.AccessLock = threading.Lock() # log errors in this module to a file self.log = SetupLogger("gentankutil", self.LogFileName) self.console = SetupLogger("gentankutil_console", log_file="", stream=True) self.MonitorAddress = host self.PollTime = 2 self.TankID = "" self.debug = False configfile = ConfigFilePath + 'gentankutil.conf' try: if not os.path.isfile(configfile): self.LogConsole("Missing config file : " + configfile) self.LogError("Missing config file : " + configfile) sys.exit(1) self.config = MyConfig(filename=configfile, section='gentankutil', log=self.log) self.PollTime = self.config.ReadValue('poll_frequency', return_type=float, default=60) self.debug = self.config.ReadValue('debug', return_type=bool, default=False) self.username = self.config.ReadValue('username', default="") self.password = self.config.ReadValue('password', default="") self.tank_name = self.config.ReadValue('tank_name', default="") if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = ProgramDefaults.LocalHost except Exception as e1: self.LogErrorLine("Error reading " + configfile + ": " + str(e1)) self.LogConsole("Error reading " + configfile + ": " + str(e1)) sys.exit(1) if self.username == "" or self.username == None or self.password == "" or self.password == None: self.LogError("Invalid user name or password, exiting") sys.exit(1) try: try: startcount = 0 while startcount <= 10: try: self.Generator = ClientInterface( host=self.MonitorAddress, port=port, log=self.log) break except Exception as e1: startcount += 1 if startcount >= 10: self.console.info("genmon not loaded.") self.LogError("Unable to connect to genmon.") sys.exit(1) time.sleep(1) continue except Exception as e1: self.LogErrorLine("Error in GenTankData init: " + str(e1)) #if not self.CheckGeneratorRequirement(): # self.LogError("Requirements not met. Exiting.") # sys.exit(1) self.tank = tankutility(self.username, self.password, self.log, debug=self.debug) # start thread monitor time for exercise self.Threads["TankCheckThread"] = MyThread(self.TankCheckThread, Name="TankCheckThread", start=False) self.Threads["TankCheckThread"].Start() atexit.register(self.Close) signal.signal(signal.SIGTERM, self.Close) signal.signal(signal.SIGINT, self.Close) except Exception as e1: self.LogErrorLine("Error in GenTankData init: " + str(e1)) self.console.error("Error in GenTankData init: " + str(e1)) sys.exit(1)
def __init__(self): super(GenExercise, self).__init__() self.LogFileName = "/var/log/genexercise.log" self.AccessLock = threading.Lock() # log errors in this module to a file self.log = SetupLogger("genexercise", self.LogFileName) self.console = SetupLogger("genexercise_console", log_file = "", stream = True) self.MonitorAddress = "127.0.0.1" self.PollTime = 2 self.ExerciseActive = False self.Debug = False try: self.config = MyConfig(filename = '/etc/genexercise.conf', section = 'genexercise', log = self.log) self.ExerciseType = self.config.ReadValue('exercise_type', default = "Normal") self.ExerciseHour = self.config.ReadValue('exercise_hour', return_type = int, default = 12) self.ExerciseMinute = self.config.ReadValue('exercise_minute', return_type = int, default = 0) self.ExerciseDayOfMonth = self.config.ReadValue('exercise_day_of_month', return_type = int, default = 1) self.ExerciseDayOfWeek = self.config.ReadValue('exercise_day_of_week', default = "Monday") self.ExerciseDuration = self.config.ReadValue('exercise_duration', return_type = float, default = 12) self.ExerciseWarmup = self.config.ReadValue('exercise_warmup', return_type = float, default = 0) self.ExerciseFrequency = self.config.ReadValue('exercise_frequency', default = "Monthly") self.MonitorAddress = self.config.ReadValue('monitor_address', default = "127.0.0.1") self.LastExerciseTime = self.config.ReadValue('last_exercise', default = None) self.UseGeneratorTime = self.config.ReadValue('use_gen_time', return_type = bool, default = False) self.Debug = self.config.ReadValue('debug', return_type = bool, default = False) # Validate settings if not self.ExerciseType.lower() in ["normal","quiet", "transfer"]: self.ExerciseType = "normal" if self.ExerciseHour > 23 or self.ExerciseHour < 0: self.ExerciseHour = 12 if self.ExerciseMinute > 59 or self.ExerciseMinute < 0: self.ExerciseMinute = 0 if not self.ExerciseDayOfWeek.lower() in ["monday", "tuesday", "wednesday","thursday","friday","saturday","sunday"]: self.ExerciseDayOfWeek = "Monday" if self.ExerciseDayOfMonth > 28 or self.ExerciseDayOfMonth < 1: self.ExerciseDayOfMonth = 1 if self.ExerciseDuration > 60: self.ExerciseDuration = 60 if self.ExerciseDuration < 5: self.ExerciseDuration = 5 if self.ExerciseWarmup > 30: self.ExerciseWarmup = 30 if self.ExerciseWarmup < 0: self.ExerciseWarmup = 0 if not self.ExerciseFrequency.lower() in ["weekly","biweekly", "monthly"]: self.ExerciseFrequency = "Monthly" if self.MonitorAddress == None or not len(self.MonitorAddress): self.MonitorAddress = "127.0.0.1" except Exception as e1: self.LogErrorLine("Error reading /etc/genexercise.conf: " + str(e1)) self.console.error("Error reading /etc/genexercise.conf: " + str(e1)) sys.exit(1) try: try: startcount = 0 while startcount <= 10: try: self.Generator = ClientInterface(host = self.MonitorAddress, log = self.log) break except Exception as e1: startcount += 1 if startcount >= 10: self.console.info("genmon not loaded.") self.LogError("Unable to connect to genmon.") sys.exit(1) time.sleep(1) continue except Exception as e1: self.LogErrorLine("Error in mygenpush init: " + str(e1)) if not self.CheckGeneratorRequirement(): self.LogError("Requirements not met. Exiting.") sys.exit(1) # start thread monitor time for exercise self.Threads["ExerciseThread"] = MyThread(self.ExerciseThread, Name = "ExerciseThread", start = False) self.Threads["ExerciseThread"].Start() try: if self.ExerciseFrequency.lower() == "monthly": DayStr = "Day " + str(self.ExerciseDayOfMonth) else: DayStr = str(self.ExerciseDayOfWeek) self.LogError("Execise: " + self.ExerciseType + ", " + self.ExerciseFrequency + " at " + str(self.ExerciseHour) + ":" + str(self.ExerciseMinute) + " on " + DayStr + " for " + str(self.ExerciseDuration) + " min. Warmup: " + str(self.ExerciseWarmup)) if self.Debug: self.LogError("Debug Enabled") except Exception as e1: self.LogErrorLine(str(e1)) atexit.register(self.Close) signal.signal(signal.SIGTERM, self.Close) signal.signal(signal.SIGINT, self.Close) except Exception as e1: self.LogErrorLine("Error in GenExercise init: " + str(e1)) self.console.error("Error in GenExercise init: " + str(e1)) sys.exit(1)