def SetupAddOnProgram(prog_name):
console = SetupLogger(prog_name + "_console", log_file="", stream=True)
if not MySupport.PermissionsOK():
console.error(
"\nYou need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.\n"
)
sys.exit(2)
HelpStr = '\nsudo python ' + prog_name + '.py -a <IP Address or localhost> -c <path to ' + prog_name + ' config file>\n'
ConfigFilePath = ProgramDefaults.ConfPath
address = ProgramDefaults.LocalHost
try:
opts, args = getopt.getopt(sys.argv[1:], "hc:a:",
["help", "configpath=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
elif opt in ("-c", "--configpath"):
ConfigFilePath = arg.strip()
try:
port, loglocation, multi_instance = MySupport.GetGenmonInitInfo(
ConfigFilePath, log=console)
log = SetupLogger("client_" + prog_name,
os.path.join(loglocation, prog_name + ".log"))
if not prog_name.lower().endswith(".py"):
prog_name += ".py"
attempts = 0
while True:
if MySupport.IsRunning(prog_name=prog_name,
log=log,
multi_instance=multi_instance):
if attempts >= 4:
raise Exception("The program %s is already loaded" %
prog_name)
else:
attempts += 1
time.sleep(1)
else:
break
except Exception as e1:
console.error("Error : " + str(e1))
log.error("Error : " + str(e1))
sys.exit(1)
return console, ConfigFilePath, address, port, loglocation, log
try:
MyClientInterface.Close()
except Exception as e1:
log.error("Error: signal_handler: " + str(e1))
sys.exit(0)
#------------------- Command-line interface for gengpioin ----------------------
if __name__=='__main__':
address=ProgramDefaults.LocalHost
try:
console = SetupLogger("genalexa_console", log_file = "", stream = True)
if os.geteuid() != 0:
console.error("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.")
sys.exit(2)
HelpStr = '\nsudo python genalexa.py -a <IP Address or localhost> -c <path to genmon config file>\n'
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:],"hc:a:",["help","configpath=","address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
sys.exit(0)
#------------------- Command-line interface for gengpio ------------------------
if __name__ == '__main__': # usage program.py [server_address]
address = ProgramDefaults.LocalHost
try:
console = SetupLogger("gengpio_console", log_file="", stream=True)
HelpStr = '\nsudo python gengpio.py -a <IP Address or localhost> -c <path to genmon config file>\n'
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:], "hc:a:",
["help", "configpath=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
elif opt in ("-c", "--configpath"):
ConfigFilePath = arg
ConfigFilePath = ConfigFilePath.strip()
port, loglocation = MySupport.GetGenmonInitInfo(ConfigFilePath,
log=console)
log = SetupLogger("client", loglocation + "gengpio.log")
signal.signal(signal.SIGINT, signal_handler)
if os.geteuid() != 0:
print(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
log = SetupLogger("client", "/var/log/gensyslog.log")
console = SetupLogger("gensyslog_console", log_file="", stream=True)
try:
GenNotify = GenNotify(host=address,
onready=OnReady,
onexercise=OnExercise,
onrun=OnRun,
onrunmanual=OnRunManual,
onalarm=OnAlarm,
onservice=OnService,
onoff=OnOff,
onmanual=OnManual,
onutilitychange=OnUtilityChange,
log=log)
while True:
time.sleep(1)
except Exception as e1:
log.error("Error: " + str(e1))
console.error("Error: " + str(e1))
except Exception as e1:
log.error("Error in SendNotice: " + str(e1))
console.error("Error in SendNotice: " + str(e1))
#------------------- Command-line interface for gengpio ------------------------
if __name__=='__main__':
address=ProgramDefaults.LocalHost
# Set the signal handler
signal.signal(signal.SIGINT, signal_handler)
console = SetupLogger("slack_console", log_file = "", stream = True)
HelpStr = '\nsudo python genslack.py -a <IP Address or localhost> -c <path to genmon config file>\n'
if os.geteuid() != 0:
console.error("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.")
sys.exit(2)
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:],"hc:a:",["configpath=","address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
class MyMQTT(MyCommon):
#------------ MyMQTT::init--------------------------------------------------
def __init__(self,
log = None,
loglocation = ProgramDefaults.LogPath,
host = ProgramDefaults.LocalHost,
port = ProgramDefaults.ServerPort,
configfilepath = ProgramDefaults.ConfPath):
super(MyMQTT, self).__init__()
self.LogFileName = loglocation + "genmqtt.log"
if log != None:
self.log = log
else:
# log errors in this module to a file
self.log = SetupLogger("client", self.LogFileName)
# cleanup
# test
self.console = SetupLogger("mymqtt_console", log_file = "", stream = True)
self.Username = None
self.Password = None
self.Topic = None
self.MQTTAddress = None
self.MonitorAddress = host
self.MQTTPort = 1883
self.Topic = "generator"
self.TopicRoot = None
self.BlackList = None
self.UseNumeric = False
self.PollTime = 2
self.FlushInterval = float('inf') # default to inifite flush interval (e.g., never)
self.Debug = False
try:
config = MyConfig(filename = configfilepath + 'genmqtt.conf', section = 'genmqtt', log = log)
self.Username = config.ReadValue('username')
self.Password = config.ReadValue('password')
self.MQTTAddress = config.ReadValue('mqtt_address')
if self.MQTTAddress == None or not len(self.MQTTAddress):
log.error("Error: invalid MQTT server address")
console.error("Error: invalid MQTT server address")
sys.exit(1)
self.MonitorAddress = config.ReadValue('monitor_address', default = self.MonitorAddress)
if self.MonitorAddress == None or not len(self.MonitorAddress):
self.MonitorAddress = ProgramDefaults.LocalHost
self.MQTTPort = config.ReadValue('mqtt_port', return_type = int, default = 1883)
self.PollTime = config.ReadValue('poll_interval', return_type = float, default = 2.0)
self.UseNumeric = config.ReadValue('numeric_json', return_type = bool, default = False)
self.TopicRoot = config.ReadValue('root_topic')
#http://www.steves-internet-guide.com/mosquitto-tls/
self.CertificateAuthorityPath = config.ReadValue('cert_authority_path', default = "")
self.TLSVersion = config.ReadValue('tls_version', return_type = str, default = "1.0")
self.CertReqs = config.ReadValue('cert_reqs', return_type = str, default = "Required")
BlackList = config.ReadValue('blacklist')
if BlackList != None:
if len(BlackList):
BList = BlackList.strip().split(",")
if len(BList):
self.BlackList = []
for Items in BList:
self.BlackList.append(Items.strip())
self.Debug = config.ReadValue('debug', return_type = bool, default = False)
if config.HasOption('flush_interval'):
self.FlushInterval = config.ReadValue('flush_interval', return_type = float, default = float('inf'))
if self.FlushInterval == 0:
self.FlushInterval = float('inf')
else:
self.FlushInterval = float('inf')
except Exception as e1:
self.LogErrorLine("Error reading " + configfilepath + "genmqtt.conf: " + str(e1))
self.console.error("Error reading " + configfilepath + "genmqtt.conf: " + str(e1))
sys.exit(1)
try:
self.MQTTclient = mqtt.Client(client_id = "genmon")
if self.Username != None and len(self.Username) and self.Password != None:
self.MQTTclient.username_pw_set(self.Username, password=self.Password)
self.MQTTclient.on_connect = self.on_connect
self.MQTTclient.on_message = self.on_message
if len(self.CertificateAuthorityPath):
if os.path.isfile(self.CertificateAuthorityPath):
cert_reqs = ssl.CERT_REQUIRED
if self.CertReqs.lower() == "required":
cert_reqs = ssl.CERT_REQUIRED
elif self.CertReqs.lower() == "optional":
cert_reqs = ssl.CERT_REQUIRED
elif self.CertReqs.lower() == "none":
cert_reqs = ssl.CERT_NONE
else:
self.LogError("Error: invalid cert required specified, defaulting to required: " + self.self.CertReq)
use_tls = ssl.PROTOCOL_TLSv1
if self.TLSVersion == "1.0" or self.TLSVersion == "1":
use_tls = ssl.PROTOCOL_TLSv1
elif self.TLSVersion == "1.1":
use_tls = ssl.PROTOCOL_TLSv1_1
elif self.TLSVersion == "1.2":
use_tls = ssl.PROTOCOL_TLSv1_2
else:
self.LogError("Error: invalid TLS version specified, defaulting to 1.0: " + self.TLSVersion)
self.MQTTclient.tls_set(ca_certs = self.CertificateAuthorityPath,cert_reqs = cert_reqs, tls_version = use_tls )
self.MQTTPort = 8883 # port for SSL
else:
self.LogError("Error: Unable to find CA cert file: " + self.CertificateAuthorityPath)
self.MQTTclient.connect(self.MQTTAddress, self.MQTTPort, 60)
self.Push = MyGenPush(host = self.MonitorAddress,
log = self.log, callback = self.PublishCallback,
polltime = self.PollTime , blacklist = self.BlackList,
flush_interval = self.FlushInterval, use_numeric = self.UseNumeric,
debug = self.Debug, port = port, loglocation = loglocation)
atexit.register(self.Close)
signal.signal(signal.SIGTERM, self.Close)
signal.signal(signal.SIGINT, self.Close)
self.MQTTclient.loop_start()
except Exception as e1:
self.LogErrorLine("Error in MyMQTT init: " + str(e1))
self.console.error("Error in MyMQTT init: " + str(e1))
sys.exit(1)
#------------ MyMQTT::PublishCallback---------------------------------------
# Callback to publish data via MQTT
def PublishCallback(self, name, value):
try:
if self.TopicRoot != None and len(self.TopicRoot):
FullPath = self.TopicRoot + "/" + str(name)
else:
FullPath = str(name)
if self.Debug:
self.console.info("Publish: " + FullPath + ": " + str(value) + ": " + str(type(value)))
self.MQTTclient.publish(FullPath, value)
except Exception as e1:
self.LogErrorLine("Error in MyMQTT:PublishCallback: " + str(e1))
#------------ MyMQTT::on_connect--------------------------------------------
# The callback for when the client receives a CONNACK response from the server.
def on_connect(self, client, userdata, flags, rc):
if rc != 0:
self.LogError("Error connecting to MQTT server: return code: " + str(rc))
self.console.info("Connected with result code "+str(rc))
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
self.MQTTclient.subscribe(self.Topic + "/#")
#------------ MyMQTT::on_message--------------------------------------------
# The callback for when a PUBLISH message is received from the server.
def on_message(self, client, userdata, msg):
if self.Debug:
self.console.info("Confirmed: " + msg.topic + ": " + str(msg.payload))
# ---------- MyMQTT::Close--------------------------------------------------
def Close(self):
self.Push.Close()
console.info(message.sid)
except Exception as e1:
log.error("Error: " + str(e1))
console.error("Error: " + str(e1))
#------------------- Command-line interface for gengpio ------------------------
if __name__=='__main__':
address = ProgramDefaults.LocalHost
# Set the signal handler
signal.signal(signal.SIGINT, signal_handler)
console = SetupLogger("sms_console", log_file = "", stream = True)
HelpStr = '\nsudo python gensyslog.py -a <IP Address or localhost> -c <path to genmon config file>\n'
if os.geteuid() != 0:
console.error("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.")
sys.exit(2)
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:],"hc:a:",["help","configpath=","address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
class SerialTCPDevice(MySupport):
def __init__(self, log=None, host="127.0.0.1", port=8899, config=None):
super(SerialTCPDevice, self).__init__()
self.DeviceName = "serialTCP"
self.config = config
self.Buffer = []
self.BufferLock = threading.Lock()
self.DiscardedBytes = 0
self.Restarts = 0
self.SerialStartTime = datetime.datetime.now() # used for com metrics
self.rxdatasize = 2000
self.SocketTimeout = 1
self.host = host
self.port = port
if self.config != None:
self.loglocation = self.config.ReadValue('loglocation',
default='/var/log/')
self.host = self.config.ReadValue('serial_tcp_address',
return_type=str,
default=None)
self.port = self.config.ReadValue('serial_tcp_port',
return_type=int,
default=None,
NoLog=True)
else:
self.loglocation = default = './'
# log errors in this module to a file
self.console = SetupLogger("myserialtcp_console",
log_file="",
stream=True)
if log == None:
self.log = SetupLogger("myserialtcp",
self.loglocation + "myserialtcp.log")
else:
self.log = log
#Starting serial connection
self.Connect()
self.IsOpen = True
self.StartReadThread()
#---------- SerialTCPDevice::Connect --------------------------------------
def Connect(self):
try:
#create an INET, STREAMing socket
self.Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.Socket.settimeout(self.SocketTimeout)
#now connect to the server on our port
self.Socket.connect((self.host, self.port))
self.Flush()
return True
except Exception as e1:
self.LogError("Error: Connect : " + str(e1))
self.console.error("Unable to make TCP connection.")
self.Socket = None
return False
# ---------- SerialTCPDevice::ResetSerialStats------------------------------
def ResetSerialStats(self):
# resets status that are time based (affected by a time change)
self.SerialStartTime = datetime.datetime.now() # used for com metrics
# ---------- SerialTCPDevice::StartReadThread-------------------------------
def StartReadThread(self):
# start read thread to monitor incoming data commands
self.Threads["SerialTCPReadThread"] = MyThread(
self.ReadThread, Name="SerialTCPReadThread")
return self.Threads["SerialTCPReadThread"]
# ---------- SerialTCPDevice::ReadThread------------------------------------
def ReadThread(self):
while True:
try:
self.Flush()
while True:
if self.Socket == None:
self.Restarts += 1
if not self.Connect():
if self.WaitForExit("SerialTCPReadThread",
10): # 10 seconds
return
continue
for c in self.Read():
with self.BufferLock:
if sys.version_info[0] < 3:
self.Buffer.append(ord(c)) # PYTHON2
else:
self.Buffer.append(c) # PYTHON3
# first check for SignalStopped is when we are receiving
if self.IsStopSignaled("SerialTCPReadThread"):
return
# second check for SignalStopped is when we are not receiving
if self.IsStopSignaled("SerialTCPReadThread"):
return
except Exception as e1:
self.LogErrorLine(
"Resetting SerialTCPDevice:ReadThread Error: " +
self.DeviceName + ":" + str(e1))
# if we get here then this is likely due to the following exception:
# "device reports readiness to read but returned no data (device disconnected?)"
# This is believed to be a kernel issue so let's just reset the device and hope
# for the best (actually this works)
if self.Socket != None:
self.Socket.close()
self.Socket = None
self.Connect()
#------------SerialTCPDevice::DiscardByte-----------------------------------
def DiscardByte(self):
if len(self.Buffer):
discard = self.Buffer.pop(0)
self.DiscardedBytes += 1
return discard
# ---------- SerialTCPDevice::Close-----------------------------------------
def Close(self):
try:
if self.IsOpen:
self.KillThread("SerialTCPReadThread")
# close socket
if self.Socket != None:
self.Socket.close()
self.Socket = None
self.IsOpen = False
except Exception as e1:
self.LogErrorLine("Error in SerialTCPDevice:Close : " + str(e1))
# ---------- SerialTCPDevice::Flush-----------------------------------------
def Flush(self):
try:
# Flush socket
with self.BufferLock: # will block if lock is already held
del self.Buffer[:]
except Exception as e1:
self.LogErrorLine("Error in SerialTCPDevice:Flush : " + str(e1))
# ---------- SerialTCPDevice::Read------------------------------------------
def Read(self):
try:
if self.Socket == None:
return ""
data = self.Socket.recv(self.rxdatasize)
if data == None:
return ""
return data
except socket.timeout as err:
return ""
except socket.error as err:
self.LogErrorLine("Error in SerialTCPDevice:Read socket error: " +
str(err))
if self.Socket != None:
self.Socket.close()
self.Socket = None
except Exception as e1:
self.LogErrorLine("Error in SerialTCPDevice:Read : " + str(e1))
if self.Socket != None:
self.Socket.close()
self.Socket = None
return ""
# ---------- SerialTCPDevice::Write-----------------------------------------
def Write(self, data):
try:
if self.Socket == None:
return None
return self.Socket.sendall(data)
except Exception as e1:
if self.Socket != None:
self.Socket.close()
self.Socket = None
self.LogErrorLine("Error in SerialTCPDevice:Write : " + str(e1))
return 0
# ---------- SerialTCPDevice::GetRxBufferAsString---------------------------
def GetRxBufferAsString(self):
try:
if not len(self.Buffer):
return ""
with self.BufferLock:
str1 = ''.join(chr(e) for e in self.Buffer)
return str1
except Exception as e1:
self.LogErrorLine(
"Error in SerialTCPDevice:GetRxBufferAsString: " + str(e1))
return ""
sys.exit(2)
console = SetupLogger("sms_console", log_file = "", stream = True)
log = SetupLogger("client", "/var/log/gensms.log")
try:
config = MyConfig(filename = '/etc/gensms.conf', section = 'gensms', log = log)
account_sid = config.ReadValue('accountsid', default = "")
auth_token = config.ReadValue('authtoken', default = "")
to_number = config.ReadValue('to_number', default = "")
from_number = config.ReadValue('from_number', default = "")
if account_sid == "" or auth_token == "" or to_number == "" or from_number == "":
log.error("Missing parameter in /etc/gensms.conf")
console.error("Missing parameter in /etc/gensms.conf")
sys.exit(1)
except Exception as e1:
log.error("Error reading /etc/gensms.conf: " + str(e1))
console.error("Error reading /etc/gensms.conf: " + str(e1))
sys.exit(1)
try:
GenNotify = GenNotify(
host = address,
onready = OnReady,
onexercise = OnExercise,
onrun = OnRun,
onrunmanual = OnRunManual,
onalarm = OnAlarm,
class GenExercise(MySupport):
#------------ GenExercise::init---------------------------------------------
def __init__(self,
log = None,
loglocation = ProgramDefaults.LogPath,
ConfigFilePath = MyCommon.DefaultConfPath,
host = ProgramDefaults.LocalHost,
port = ProgramDefaults.ServerPort):
super(GenExercise, self).__init__()
self.LogFileName = loglocation + "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 = host
self.PollTime = 2
self.ExerciseActive = False
self.Debug = False
try:
self.config = MyConfig(filename = 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 " + ConfigFilePath + "genexercise.conf: " + str(e1))
self.console.error("Error reading " + ConfigFilePath + "genexercise.conf: " + 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 genexercise 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))
self.DebugOutput("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)
#---------- GenExercise::SendCommand --------------------------------------
def SendCommand(self, Command):
if len(Command) == 0:
return "Invalid Command"
try:
with self.AccessLock:
data = self.Generator.ProcessMonitorCommand(Command)
except Exception as e1:
self.LogErrorLine("Error calling ProcessMonitorCommand: " + str(Command))
data = ""
return data
#---------- GenExercise::CheckGeneratorRequirement ------------------------
def CheckGeneratorRequirement(self):
try:
data = self.SendCommand("generator: start_info_json")
StartInfo = {}
StartInfo = json.loads(data)
if not "evolution" in StartInfo["Controller"].lower() and not "nexus" in StartInfo["Controller"].lower():
self.LogError("Error: Only Evolution or Nexus controllers are supported for this feature: " + StartInfo["Controller"])
return False
return True
except Exception as e1:
self.LogErrorLine("Error in CheckGeneratorRequirement: " + str(e1))
return False
# ---------- GenExercise::PostWarmup----------------------------------------
def PostWarmup(self):
# check to see if the generator is running
status = self.SendCommand("generator: getbase")
if not status.lower() in ["running", "exercising"]:
self.LogError("WARNING: generator not running post warmup. Transfer switch not activated.")
self.SendCommand("generator: setremote=stop")
return
self.SendCommand("generator: setremote=starttransfer")
self.DebugOutput("Starting transfer exercise cycle (post warmup).")
# set timer to stop
self.StopTimer = threading.Timer(float(self.ExerciseDuration * 60.0), self.StopExercise)
self.StopTimer.start()
# ---------- GenExercise::ReadyToExercise-----------------------------------
def ReadyToExercise(self):
status = self.SendCommand("generator: getbase")
if not status.lower() in ["ready"]:
self.LogError("Generator not in Ready state, exercise cycle not started")
return False
return True
# ---------- GenExercise::StartExercise-------------------------------------
def StartExercise(self):
if self.ExerciseActive:
# already active
return
# Start generator
if self.ExerciseType.lower() == "normal" and self.ReadyToExercise():
self.SendCommand("generator: setremote=start")
self.DebugOutput("Starting normal exercise cycle.")
self.StopTimer = threading.Timer(float(self.ExerciseDuration * 60.0), self.StopExercise)
self.StopTimer.start()
elif self.ExerciseType.lower() == "quiet" and self.ReadyToExercise():
self.SendCommand("generator: setremote=startexercise")
self.DebugOutput("Starting quiet exercise cycle.")
self.StopTimer = threading.Timer(float(self.ExerciseDuration * 60.0), self.StopExercise)
self.StopTimer.start()
elif self.ExerciseType.lower() == "transfer" and self.ReadyToExercise():
if self.ExerciseWarmup == 0:
self.SendCommand("generator: setremote=starttransfer")
self.DebugOutput("Starting transfer exercise cycle.")
self.StopTimer = threading.Timer(float(self.ExerciseDuration * 60.0), self.StopExercise)
self.StopTimer.start()
else:
self.SendCommand("generator: setremote=start")
self.DebugOutput("Starting warmup for transfer exercise cycle.")
# start timer for post warmup transition to starttransfer command
self.WarmupTimer = threading.Timer(float(self.ExerciseWarmup * 60.0), self.PostWarmup)
self.WarmupTimer.start()
else:
self.LogError("Invalid mode in StartExercise: " + str(self.ExerciseType))
return
self.WriteLastExerciseTime()
self.ExerciseActive = True
# ---------- GenExercise::StopExercise--------------------------------------
def StopExercise(self):
if self.ExerciseActive:
self.SendCommand("generator: setremote=stop")
self.DebugOutput("Stopping exercise cycle.")
self.ExerciseActive = False
else:
self.DebugOutput("Calling Stop Exercise (not needed)")
# ---------- GenExercise::DebugOutput-----------------------------
def DebugOutput(self, Message):
if self.Debug:
self.LogError(Message)
# ---------- GenExercise::WriteLastExerciseTime-----------------------------
def WriteLastExerciseTime(self):
try:
NowString = datetime.datetime.now().strftime("%A %B %d, %Y %H:%M:%S")
if self.ExerciseFrequency.lower() == "biweekly":
self.config.WriteValue("last_exercise", NowString)
self.config.LastExerciseTime = NowString
self.DebugOutput("Last Exercise Cycle: " + NowString)
except Exception as e1:
self.LogErrorLine("Error in WriteLastExerciseTime: " + str(e1))
# ---------- GenExercise::TimeForExercise-----------------------------------
def TimeForExercise(self):
try:
if self.UseGeneratorTime:
TimeNow = self.GetGeneratorTime()
else:
TimeNow = datetime.datetime.now()
if TimeNow.hour != self.ExerciseHour or TimeNow.minute != self.ExerciseMinute:
return False
weekDays = ("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday")
WeekDayString = weekDays[TimeNow.weekday()]
if not self.ExerciseFrequency.lower() in ["weekly", "biweekly", "monthly"]:
self.LogError("Invalid Exercise Frequency in TimeForExercise: " + str(self.ExerciseFrequency))
return False
if self.ExerciseFrequency.lower() == "weekly" and self.ExerciseDayOfWeek.lower() == WeekDayString.lower():
return True
elif self.ExerciseFrequency.lower() == "biweekly" and self.ExerciseDayOfWeek.lower() == WeekDayString.lower():
if self.LastExerciseTime == None:
return True
LastExerciseTime = datetime.datetime.strptime(self.LastExerciseTime, "%A %B %d, %Y %H:%M:%S")
if (TimeNow - LastExerciseTime).days >= 14:
return True
return False
elif self.ExerciseFrequency.lower() == "monthly" and TimeNow.day == self.ExerciseDayOfMonth:
return True
else:
return False
except Exception as e1:
self.LogErrorLine("Error in TimeForExercise: " + str(e1))
return False
# ---------- GenExercise::GetGeneratorTime----------------------------------
def GetGeneratorTime(self):
try:
GenTimeStr = ""
data = self.SendCommand("generator: status_json")
Status = {}
Status = json.loads(data)
TimeDict = self.FindDictValueInListByKey("Time", Status["Status"])
if TimeDict != None:
TimeDictStr = self.FindDictValueInListByKey("Generator Time", TimeDict)
if TimeDictStr != None or not len(TimeDictStr):
GenTimeStr = TimeDictStr
# Format is "Wednesday March 6, 2019 13:10" or " "Friday May 3, 2019 11:11"
GenTime = datetime.datetime.strptime(GenTimeStr, "%A %B %d, %Y %H:%M")
else:
self.LogError("Error getting generator time! Genmon may be starting up.")
GenTime = datetime.datetime.now()
else:
self.LogError("Error getting generator time (2)!")
GenTime = datetime.datetime.now()
return GenTime
except Exception as e1:
self.LogErrorLine("Error in GetGeneratorTime: " + str(e1) + ": " + GenTimeStr)
return datetime.datetime.now()
# ---------- GenExercise::ExerciseThread------------------------------------
def ExerciseThread(self):
time.sleep(1)
while True:
try:
if not self.ExerciseActive:
if self.TimeForExercise():
self.StartExercise()
if self.WaitForExit("ExerciseThread", float(self.PollTime)):
return
except Exception as e1:
self.LogErrorLine("Error in ExerciseThread: " + str(e1))
if self.WaitForExit("ExerciseThread", float(self.PollTime)):
return
# ----------GenExercise::Close----------------------------------------------
def Close(self):
self.KillThread("ExerciseThread")
if self.ExerciseActive:
try:
self.WarmupTimer.cancel()
except:
pass
try:
self.StopTimer.cancel()
except:
pass
self.StopExercise()
self.Generator.Close()
if os.geteuid() != 0:
print(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
console = SetupLogger("emailsms_console", log_file="", stream=True)
HelpStr = '\nsudo python genemail2sms.py -a <IP Address or localhost> -c <path to genmon config file>\n'
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:], "hc:a:",
["help", "configpath=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
elif opt in ("-c", "--configpath"):
ConfigFilePath = arg
ConfigFilePath = ConfigFilePath.strip()
port, loglocation = MySupport.GetGenmonInitInfo(ConfigFilePath,
log=console)
log = SetupLogger("client", os.path.join(loglocation, "genemail2sms.log"))
# log errors in this module to a file
console = SetupLogger("client_console", log_file="", stream=True)
log = SetupLogger("client", "client.log")
# Set the signal handler
signal.signal(signal.SIGINT, signal_handler)
startcount = 0
while startcount <= 2:
try:
MyClientInterface = ClientInterface(host=address, log=log)
break
except Exception as e1:
startcount += 1
if startcount >= 2:
console.error("Error: genmon not loaded.")
sys.exit(1)
time.sleep(1)
continue
try:
while True:
try:
line = raw_input(">")
except NameError:
pass
line = input(">")
if line.lower() == "exit":
break
log.error("Error: " + str(e1))
console.error("Error: " + str(e1))
#------------------- Command-line interface for gengpio ------------------------
if __name__ == '__main__':
address = ProgramDefaults.LocalHost
# Set the signal handler
signal.signal(signal.SIGINT, signal_handler)
console = SetupLogger("pushover_console", log_file="", stream=True)
HelpStr = '\nsudo python genpushover.py -a <IP Address or localhost> -c <path to genmon config file>\n'
if os.geteuid() != 0:
console.error(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:], "hc:a:",
["help", "configpath=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
Settings += " Resitor Pull Up "
elif DefaultPullup == GPIO.PUD_DOWN:
Settings += " Resitor Pull Down "
else:
Settings += " Resitor Pull Unknown "
if DefaultTrigger == GPIO.RISING:
Settings += " Trigger Rising "
elif DefaultTrigger == GPIO.FALLING:
Settings += " Trigger Falling "
elif DefaultTrigger == GPIO.BOTH:
Settings += " Trigger Both "
else:
Settings += " Trigger Unknown "
log.error("Settings: " + Settings + " bounce = " + str(DefaultBounce))
MyClientInterface = ClientInterface(host=address, log=log)
#setup GPIO using Board numbering
GPIO.setmode(GPIO.BOARD)
#log.info( GPIO.RPI_INFO)
#log.info(GPIO.VERSION)
ChannelList = {
INPUT_STOP: StopCallBack,
INPUT_START: StartCallBack,
INPUT_START_TRANSFER: StartTransferCallBack
}
GPIO.setwarnings(True)
log.error("Error: " + str(e1))
console.error("Error: " + str(e1))
#------------------- Command-line interface for gengpio -----------------------#
if __name__ == '__main__':
address = ProgramDefaults.LocalHost
# Set the signal handler
signal.signal(signal.SIGINT, signal_handler)
console = SetupLogger("sms_console_modem", log_file="", stream=True)
HelpStr = '\nsudo python gensmns_modem.py -a <IP Address or localhost> -c <path to genmon config file>\n'
if os.geteuid() != 0:
console.error(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:], "hc:a:",
["help", "configpath=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
sys.exit(0)
#------------------- Command-line interface for monitor -----------------#
if __name__ == '__main__': # usage program.py [server_address] [port]
address = ProgramDefaults.LocalHost
port = ProgramDefaults.ServerPort
# log errors in this module to a file
console = SetupLogger("client_console", log_file="", stream=True)
HelpStr = '\npython ClientInterface.py -a <IP Address or none for localhost> -p <port or none for default port>\n'
try:
opts, args = getopt.getopt(sys.argv[1:], "hp:a:",
["help", "port=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
try:
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
elif opt in ("-p", "--port"):
port = int(arg)
except Exception as e1:
console.error("Error parsing: " + str(e1))
sys.exit(2)
# Set the signal handler
signal.signal(signal.SIGINT, signal_handler)
if os.geteuid() != 0:
print("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.")
sys.exit(2)
console = SetupLogger("emailsms_console", log_file = "", stream = True)
HelpStr = '\nsudo python genemail2sms.py -a <IP Address or localhost> -c <path to genmon config file>\n'
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:],"hc:a:",["help","configpath=","address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
elif opt in ("-c", "--configpath"):
ConfigFilePath = arg
ConfigFilePath = ConfigFilePath.strip()
port, loglocation = MySupport.GetGenmonInitInfo(ConfigFilePath, log = console)
log = SetupLogger("client", loglocation + "genemail2sms.log")
class GenTankData(MySupport):
# The device is the ADS1115 I2C ADC
# reference python http://www.smartypies.com/projects/ads1115-with-raspberrypi-and-python/ads1115runner/
RESET_ADDRESS = 0b0000000
RESET_COMMAND = 0b00000110
POINTER_CONVERSION = 0x0
POINTER_CONFIGURATION = 0x1
POINTER_LOW_THRESHOLD = 0x2
POINTER_HIGH_THRESHOLD = 0x3
#------------ GenTankData::init---------------------------------------------
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)
#---------- GenTankData::SendCommand --------------------------------------
def SendCommand(self, Command):
if len(Command) == 0:
return "Invalid Command"
try:
with self.AccessLock:
data = self.Generator.ProcessMonitorCommand(Command)
except Exception as e1:
self.LogErrorLine("Error calling ProcessMonitorCommand: " +
str(Command))
data = ""
return data
# ---------- GenTankData::InitADC-------------------------------------------
def InitADC(self):
try:
# I2C channel 1 is connected to the GPIO pins
self.I2Cbus = smbus.SMBus(self.i2c_channel)
# Reset ADC
self.I2Cbus.write_byte(self.RESET_ADDRESS, self.RESET_COMMAND)
# set config register and start conversion
# ANC1 and GND, 4.096v, 128s/s
# Customized - Port A0 and 4.096 V input
# 0b11000011; # bit 15-8 = 0xC3
# bit 15 flag bit for single shot
# Bits 14-12 input selection:
# 100 ANC0; 101 ANC1; 110 ANC2; 111 ANC3
# Bits 11-9 Amp gain. Default to 010 here 001 P19
# Bit 8 Operational mode of the ADS1115.
# 0 : Continuous conversion mode
# 1 : Power-down single-shot mode (default)
CONFIG_VALUE_1 = 0xC3
# bits 7-0 0b10000101 = 0x85
# Bits 7-5 data rate default to 100 for 128SPS
# Bits 4-0 comparator functions see spec sheet.
CONFIG_VALUE_2 = 0x85
self.I2Cbus.write_i2c_block_data(self.i2c_address,
self.POINTER_CONFIGURATION,
[CONFIG_VALUE_1, CONFIG_VALUE_2])
self.LogDebug("I2C Init complete: success")
except Exception as e1:
self.LogErrorLine("Error calling InitADC: " + str(e1))
return False
return True
# ---------- GenTankData::GetGaugeData--------------------------------------
def GetGaugeData(self):
try:
val = self.I2Cbus.read_i2c_block_data(self.i2c_address,
self.POINTER_CONVERSION, 2)
self.LogDebug(str(val))
# convert display results
reading = val[0] << 8 | val[1]
if (reading < 0):
reading = 0
#reading = self.I2Cbus.read_word_data(self.i2c_address, self.i2c_channel)
volts = round(
float(reading * (float(self.mv_per_step) / 1000000.0)), 2)
gauge_data = float(self.Multiplier) * volts
self.LogDebug("Reading Gauge Data: %4.2f%%" % gauge_data)
return gauge_data
except Exception as e1:
self.LogErrorLine("Error calling GetGaugeData: " + str(e1))
return 0.0
# ---------- GenTankData::TankCheckThread-----------------------------------
def TankCheckThread(self):
time.sleep(1)
while True:
try:
dataforgenmon = {}
tankdata = self.GetGaugeData()
if tankdata != None:
dataforgenmon["Tank Name"] = "External Tank"
dataforgenmon["Capacity"] = 0
dataforgenmon["Percentage"] = self.GetGaugeData()
retVal = self.SendCommand("generator: set_tank_data=" +
json.dumps(dataforgenmon))
self.LogDebug(retVal)
if self.WaitForExit("TankCheckThread",
float(self.PollTime * 60)):
return
except Exception as e1:
self.LogErrorLine("Error in TankCheckThread: " + str(e1))
if self.WaitForExit("TankCheckThread",
float(self.PollTime * 60)):
return
# ----------GenTankData::Close----------------------------------------------
def Close(self):
self.KillThread("TankCheckThread")
self.Generator.Close()
class GenTankData(MySupport):
#------------ GenTankData::init---------------------------------------------
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)
#---------- GenTankData::SendCommand --------------------------------------
def SendCommand(self, Command):
if len(Command) == 0:
return "Invalid Command"
try:
with self.AccessLock:
data = self.Generator.ProcessMonitorCommand(Command)
except Exception as e1:
self.LogErrorLine("Error calling ProcessMonitorCommand: " +
str(Command))
data = ""
return data
#---------- GenTankData::CheckGeneratorRequirement ------------------------
def CheckGeneratorRequirement(self):
try:
data = self.SendCommand("generator: start_info_json")
StartInfo = {}
StartInfo = json.loads(data)
if not "evolution" in StartInfo["Controller"].lower(
) and not "nexus" in StartInfo["Controller"].lower():
self.LogError(
"Error: Only Evolution or Nexus controllers are supported for this feature: "
+ StartInfo["Controller"])
return False
return True
except Exception as e1:
self.LogErrorLine("Error in CheckGeneratorRequirement: " + str(e1))
return False
# ---------- GenTankData::Login---------------------------------------------
def Login(self, force=False):
if force:
self.TankID = ""
if len(self.TankID):
# already logged in
return True
if not self.tank.Login():
return False
self.TankID = self.tank.GetIDFromName(self.tank_name)
if not len(self.TankID):
return False
return True
# ---------- GenTankData::TankCheckThread-----------------------------------
def TankCheckThread(self):
time.sleep(1)
LastLoginTime = datetime.datetime.now()
while True:
try:
NUMBER_OF_SECONDS = 60 * 60 * 12 # 12 hours
if ((datetime.datetime.now() - LastLoginTime).total_seconds() >
NUMBER_OF_SECONDS) or not len(self.TankID):
self.LogDebug("Login ")
if not self.Login(force=True):
self.LogError(
"Error logging in in TankCheckThread, retrying")
dataforgenmon = {}
tankdata = self.tank.GetData(self.TankID)
if tankdata != None:
dataforgenmon["Tank Name"] = tankdata["name"]
dataforgenmon["Capacity"] = self.tank.GetCapacity()
dataforgenmon["Percentage"] = self.tank.GetPercentage()
retVal = self.SendCommand("generator: set_tank_data=" +
json.dumps(dataforgenmon))
self.LogDebug(retVal)
if self.WaitForExit("TankCheckThread",
float(self.PollTime * 60)):
return
except Exception as e1:
self.LogErrorLine("Error in TankCheckThread: " + str(e1))
if self.WaitForExit("TankCheckThread",
float(self.PollTime * 60)):
return
# ----------GenTankData::Close----------------------------------------------
def Close(self):
self.KillThread("TankCheckThread")
self.Generator.Close()
console = SetupLogger("pushover_console", log_file="", stream=True)
log = SetupLogger("client", "/var/log/genpushover.log")
try:
config = MyConfig(filename='/etc/genpushover.conf',
section='genpushover',
log=log)
appid = config.ReadValue('appid')
userid = config.ReadValue('userid')
pushsound = config.ReadValue('pushsound', default='updown')
if appid == None or not len(appid):
log.error("Error: invalid app ID")
console.error("Error: invalid app ID")
sys.exit(2)
if userid == None or not len(userid):
log.error("Error: invalid user ID")
console.error("Error: invalid user ID")
sys.exit(2)
except Exception as e1:
log.error("Error reading /etc/genpushover.conf: " + str(e1))
console.error("Error reading /etc/genpushover.conf: " + str(e1))
sys.exit(1)
try:
GenNotify = GenNotify(host=address,
onready=OnReady,
if self.Debug:
self.console.info("Confirmed: " + msg.topic + ": " + str(msg.payload))
# ---------- MyMQTT::Close--------------------------------------------------
def Close(self):
self.Push.Close()
#-------------------------------------------------------------------------------
if __name__ == "__main__":
address=ProgramDefaults.LocalHost
console = SetupLogger("genmqtt_console_", log_file = "", stream = True)
HelpStr = '\nsudo python genmqtt.py -a <IP Address or localhost> -c <path to genmon config file>\n'
if os.geteuid() != 0:
console.error("\nYou need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.\n")
sys.exit(2)
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:],"hc:a:",["help","configpath=","address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
except getopt.GetoptError:
print(HelpStr)
sys.exit(2)
configfilename = "gentankdiy.conf"
configfile = os.path.join(MyCommon.DefaultConfPath, configfilename)
for opt, arg in opts:
if opt == '-h':
print(HelpStr)
sys.exit()
elif opt in ("-c"):
configfile = os.path.join(arg, configfilename)
if not os.path.isfile(configfile):
console.error("Missing config file: {0}".format(configfile))
sys.exit(1)
console.error("Using config file %s" % configfile)
config = MyConfig(filename=configfile, section='gentankdiy')
gauge = GaugeDIY2(config, console=console, log=console)
if not gauge.InitADC():
console.error("Error initializing ADC, exiting")
exit(2)
average_n = 10
while True:
address = ProgramDefaults.LocalHost
fileName = ""
HelpStr = '\npython genlog.py -a <IP Address or localhost> -f <outputfile> -c <config file path>\n'
try:
ConfigFilePath = ProgramDefaults.ConfPath
console = SetupLogger("genlog_console", log_file="", stream=True)
port, loglocation, multi_instance = MySupport.GetGenmonInitInfo(
ConfigFilePath, log=console)
if not MySupport.PermissionsOK():
console.error(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
if MySupport.IsRunning(os.path.basename(__file__),
multi_instance=multi_instance):
console.error("The program %s is already loaded" %
os.path.basename(__file__))
sys.exit(2)
opts, args = getopt.getopt(
sys.argv[1:], "ha:f:c:",
["help", "address=", "filename=", "configpath="])
except getopt.GetoptError:
console.error(HelpStr)
sys.exit(2)
GPIO.output(ER_WARNING, GPIO.LOW)
# Get Genmon status
try:
data = MyClientInterface.ProcessMonitorCommand(
"generator: monitor_json")
TempDict = {}
TempDict = json.loads(data)
HealthStr = TempDict["Monitor"][0]["Generator Monitor Stats"][
0]["Monitor Health"]
if HealthStr.lower() == "ok":
GPIO.output(ER_INTERNET, GPIO.LOW)
else:
GPIO.output(ER_INTERNET, GPIO.HIGH)
except Exception as e1:
log.error("Error getting monitor health: " + str(e1))
# get Internet Status
try:
data = MyClientInterface.ProcessMonitorCommand(
"generator: network_status")
if data.lower() == "ok":
GPIO.output(ER_INTERNET, GPIO.LOW)
else:
GPIO.output(ER_INTERNET, GPIO.HIGH)
time.sleep(3)
except Exception as e1:
log.error("Error getting internet status: " + str(e1))
except Exception as e1:
log.error("Error: " + str(e1))
console.error("Error: " + str(e1))
class ClientInterface(MyCommon):
def __init__(self,
host=ProgramDefaults.LocalHost,
port=ProgramDefaults.ServerPort,
log=None,
loglocation=ProgramDefaults.LogPath):
super(ClientInterface, self).__init__()
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("client_console", log_file="", stream=True)
self.AccessLock = threading.RLock()
self.EndOfMessage = "EndOfMessage"
self.rxdatasize = 2000
self.host = host
self.port = port
self.max_reties = 10
self.Connect()
#---------- ClientInterface::Connect --------------------------------------
def Connect(self):
retries = 0
while True:
try:
#create an INET, STREAMing socket
self.Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#now connect to the server on our port
self.Socket.connect((self.host, self.port))
sRetData, data = self.Receive(
noeom=True) # Get initial status before commands are sent
self.console.info(data)
return
except Exception as e1:
retries += 1
if retries >= self.max_reties:
self.LogErrorLine("Error: Connect : " + str(e1))
self.console.error("Genmon not loaded.")
sys.exit(1)
else:
time.sleep(1)
continue
#---------- ClientInterface::SendCommand ----------------------------------
def SendCommand(self, cmd):
try:
self.Socket.sendall(cmd.encode("utf-8"))
except Exception as e1:
self.LogErrorLine("Error: TX: " + str(e1))
self.Close()
self.Connect()
#---------- ClientInterface::Receive --------------------------------------
def Receive(self, noeom=False):
with self.AccessLock:
RetStatus = True
try:
bytedata = self.Socket.recv(self.rxdatasize)
data = bytedata.decode("utf-8")
if len(data):
if not self.CheckForStarupMessage(data) or not noeom:
while not self.EndOfMessage in data:
morebytes = self.Socket.recv(self.rxdatasize)
more = morebytes.decode("utf-8")
if len(more):
if self.CheckForStarupMessage(more):
data = ""
RetStatus = False
break
data += more
if data.endswith(self.EndOfMessage):
data = data[:-len(self.EndOfMessage)]
RetStatus = True
else:
self.Connect()
return False, data
except Exception as e1:
self.LogErrorLine("Error: RX:" + str(e1))
self.Close()
self.Connect()
RetStatus = False
data = "Retry"
return RetStatus, data
#---------- ClientInterface::CheckForStarupMessage ------------------------
def CheckForStarupMessage(self, data):
# check for initial status response from monitor
if data.startswith("OK") or data.startswith(
"CRITICAL:") or data.startswith("WARNING:"):
return True
else:
return False
#---------- ClientInterface::Close ----------------------------------------
def Close(self):
self.Socket.close()
#---------- ClientInterface::ProcessMonitorCommand ------------------------
def ProcessMonitorCommand(self, cmd):
data = ""
try:
with self.AccessLock:
RetStatus = False
while RetStatus == False:
self.SendCommand(cmd)
RetStatus, data = self.Receive()
except Exception as e1:
self.LogErrorLine("Error in ProcessMonitorCommand:" + str(e1))
return data
except Exception as e1:
log.error("Error: " + str(e1))
console.error("Error: " + str(e1))
#------------------- Command-line interface for gengpio ------------------------
if __name__=='__main__': #
address=ProgramDefaults.LocalHost
HelpStr = '\nsudo python gensyslog.py -a <IP Address or localhost> -c <path to genmon config file>\n'
# Set the signal handler
signal.signal(signal.SIGINT, signal_handler)
console = SetupLogger("gensyslog_console", log_file = "", stream = True)
if os.geteuid() != 0:
console.error("You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting.")
sys.exit(2)
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:],"hc:a:",["help","configpath=","address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
lineno = exc_tb.tb_lineno
return fname + ":" + str(lineno)
#------------------- Command-line interface for gengpioin ----------------------
if __name__ == '__main__':
address = ProgramDefaults.LocalHost
try:
console = SetupLogger("gengpioin_console", log_file="", stream=True)
if os.geteuid() != 0:
console.error(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
HelpStr = '\nsudo python gengpioin.py -a <IP Address or localhost> -c <path to genmon config file>\n'
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:], "hc:a:",
["help", "configpath=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
#------------------- Command-line interface for genlog -------------------------
if __name__ == '__main__':
address = '127.0.0.1'
fileName = ""
HelpStr = '\npython genlog.py -a <IP Address or localhost> -f <outputfile>\n'
try:
console = SetupLogger("genlog_console", log_file="", stream=True)
opts, args = getopt.getopt(sys.argv[1:], "ha:f:",
["address=", "filename="])
except getopt.GetoptError:
console.error(HelpStr)
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
sys.exit()
elif opt in ("-a", "--address"):
address = arg
elif opt in ("-f", "--filename"):
fileName = arg
fileName = fileName.strip()
console.error('Address is ' + address)
console.error('Output file is ' + fileName)
if not len(fileName):
GPIO.cleanup()
MyClientInterface.Close()
sys.exit(0)
#------------------- Command-line interface for gengpio ------------------------
if __name__ == '__main__': # usage program.py [server_address]
address = ProgramDefaults.LocalHost
try:
console = SetupLogger("gengpio_console", log_file="", stream=True)
if os.geteuid() != 0:
console.error(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
HelpStr = '\nsudo python gengpio.py -a <IP Address or localhost> -c <path to genmon config file>\n'
try:
ConfigFilePath = ProgramDefaults.ConfPath
opts, args = getopt.getopt(sys.argv[1:], "hc:a:",
["help", "configpath=", "address="])
except getopt.GetoptError:
console.error("Invalid command line argument.")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
console.error(HelpStr)
if os.geteuid() != 0:
print(
"You need to have root privileges to run this script.\nPlease try again, this time using 'sudo'. Exiting."
)
sys.exit(2)
console = SetupLogger("sms_console_modem", log_file="", stream=True)
log = SetupLogger("client", "/var/log/gensms_modem.log")
try:
SMS = LTEPiHat(log=log)
if not SMS.InitComplete:
SMS.Close()
log.error("Modem Init FAILED!")
console.error("Modem Init FAILED!")
sys.exit(2)
except Exception as e1:
log.error("Error on modem init:" + str(e1))
console.error("Error modem init: " + str(e1))
sys.exit(1)
try:
GenNotify = GenNotify(host=address,
onready=OnReady,
onexercise=OnExercise,
onrun=OnRun,
onrunmanual=OnRunManual,
onalarm=OnAlarm,
onservice=OnService,