def __init__(self, updatecallback, address=0x9d, name="/dev/serial", rate=9600, loglocation="/var/log/"): self.Address = address self.Threads = {} # Dict of mythread objects self.DeviceInit = False self.CommAccessLock = threading.RLock( ) # lock to synchronize access to the serial port comms self.UpdateRegisterList = updatecallback # log errors in this module to a file self.log = mylog.SetupLogger("mymodbus", loglocation + "mymodbus.log") try: #Starting serial connection self.Slave = myserial.SerialDevice(name, rate, loglocation) self.DeviceInit = True except Exception as e1: self.FatalError("Error opening serial device: " + str(e1)) return None try: # CRCMOD library, used for CRC calculations self.ModbusCrc = crcmod.predefined.mkCrcFun('modbus') except Exception as e1: self.FatalError("Unable to find crcmod package: " + str(e1))
def __init__(self, updatecallback, address=0x9d, name="/dev/serial", rate=9600, loglocation="/var/log/"): super(ModbusBase, self).__init__() self.Address = address self.Rate = rate self.PortName = name self.InitComplete = False self.IsStopping = False self.UpdateRegisterList = updatecallback self.RxPacketCount = 0 self.TxPacketCount = 0 self.ComTimoutError = 0 self.TotalElapsedPacketeTime = 0 self.ComTimoutError = 0 self.CrcError = 0 self.CommAccessLock = threading.RLock( ) # lock to synchronize access to the serial port comms self.ModbusStartTime = datetime.datetime.now() # used for com metrics # log errors in this module to a file self.log = mylog.SetupLogger("mymodbus", loglocation + "mymodbus.log")
def __init__(self, updatecallback, address = 0x9d, name = "/dev/serial", rate=9600, loglocation = "/var/log/", inputfile = None): super(ModbusFile, self).__init__(updatecallback = updatecallback, address = address, name = name, rate = rate, loglocation = loglocation) 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 = {} if self.InputFile == None: self.InputFile = os.path.dirname(os.path.realpath(__file__)) + "/modbusregs.txt" # log errors in this module to a file self.log = mylog.SetupLogger("mymodbus", loglocation + "mymodbus.log") 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 self.ReadInputFile(self.InputFile) self.Threads["ReadInputFileThread"] = mythread.MyThread(self.ReadInputFileThread, Name = "ReadInputFileThread")
def __init__(self, monitor = False, incoming_folder = None, processed_folder = None, incoming_callback = None, localinit = False, loglocation = "/var/log/", ConfigFilePath = 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: 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.SSLEnabled = False self.Threads = {} # Dict of mythread objects # log errors in this module to a file if localinit == True: self.logfile = "mymail.log" self.configfile = "mymail.conf" else: self.logfile = loglocation + "mymail.log" self.configfile = self.ConfigFilePath + "mymail.conf" self.log = mylog.SetupLogger("mymail", self.logfile) 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.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.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, host="127.0.0.1", port=9082, log=None): super(ClientInterface, self).__init__() if log != None: self.log = log else: # log errors in this module to a file self.log = mylog.SetupLogger("client", "/var/log/myclient.log") self.console = mylog.SetupLogger("client_console", log_file="", stream=True) self.AccessLock = threading.RLock() self.EndOfMessage = "EndOfMessage" self.rxdatasize = 2000 self.host = host self.port = port self.Connect()
def __init__(self, name, rate=9600, loglocation = "/var/log/", Parity = None, OnePointFiveStopBits = None): super(SerialDevice, self).__init__() self.DeviceName = name self.BaudRate = rate self.Buffer = [] self.BufferLock = threading.Lock() self.DiscardedBytes = 0 self.Restarts = 0 self.SerialStartTime = datetime.datetime.now() # used for com metrics # log errors in this module to a file self.log = mylog.SetupLogger("myserial", loglocation + "myserial.log") #Starting serial connection self.SerialDevice = serial.Serial() self.SerialDevice.port = name self.SerialDevice.baudrate = rate self.SerialDevice.bytesize = serial.EIGHTBITS #number of bits per bytes if Parity == None: self.SerialDevice.parity = serial.PARITY_NONE #set parity check: no parity elif Parity == 1: self.SerialDevice.parity = serial.PARITY_ODD #set parity check: use odd parity else: self.SerialDevice.parity = serial.PARITY_EVEN #set parity check: use even parity if OnePointFiveStopBits == None: self.SerialDevice.stopbits = serial.STOPBITS_ONE #number of stop bits elif OnePointFiveStopBits: self.SerialDevice.stopbits = serial.STOPBITS_ONE_POINT_FIVE #number of stop bits else: self.SerialDevice.stopbits = serial.STOPBITS_ONE #number of stop bits self.SerialDevice.timeout = 0.05 # small timeout so we can check if the thread should exit self.SerialDevice.xonxoff = False #disable software flow control self.SerialDevice.rtscts = False #disable hardware (RTS/CTS) flow control self.SerialDevice.dsrdtr = False #disable hardware (DSR/DTR) flow control self.SerialDevice.writeTimeout = None #timeout for write, return when packet sent #Check if port failed to open if (self.SerialDevice.isOpen() == False): try: self.SerialDevice.open() except Exception as e: self.FatalError( "Error on open serial port %s: " % self.DeviceName + str(e)) return None else: self.FatalError( "Serial port already open: %s" % self.DeviceName) return None self.Flush() self.StartReadThread()
def __init__(self, host="127.0.0.1", port=9082, log = None): if log != None: self.log = log else: # log errors in this module to a file self.log = mylog.SetupLogger("client", "/var/log/myclient.log") self.EndOfMessage = "EndOfMessage" self.rxdatasize = 2000 self.host = host self.port = port self.Connect()
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): self.AccessLock = threading.Lock() self.ThreadList = [] self.LastEvent = None self.Events = {} # Dict for handling events if log != None: self.log = log else: # log errors in this module to a file self.log = mylog.SetupLogger("client", "/var/log/myclient.log") # 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 self.Generator = myclient.ClientInterface(host=host, log=log) # start thread to accept incoming sockets for nagios heartbeat self.StartThread(self.MainPollingThread, Name="PollingThread")
def __init__(self, updatecallback, address = 0x9d, name = "/dev/serial", rate=9600, config = None): super(ModbusBase, self).__init__() self.Address = address self.Rate = rate self.PortName = name self.config = config self.InitComplete = False self.IsStopping = False self.UpdateRegisterList = updatecallback self.RxPacketCount = 0 self.TxPacketCount = 0 self.ComTimoutError = 0 self.TotalElapsedPacketeTime = 0 self.SlaveException = 0 self.CrcError = 0 self.ComValidationError = 0 self.UnexpectedData = 0 self.SlowCPUOptimization = False self.UseTCP = False if self.config != None: self.loglocation = self.config.ReadValue('loglocation', default = '/var/log/') self.SlowCPUOptimization = self.config.ReadValue('optimizeforslowercpu', return_type = bool, default = False) self.UseTCP = self.config.ReadValue('use_serial_tcp', return_type = bool, default = False) self.Address = int(self.config.ReadValue('address', default = '9d'),16) # modbus address self.AdditionalModbusTimeout = self.config.ReadValue('additional_modbus_timeout', return_type = float, default = 0.0) else: self.loglocation = default = './' self.CommAccessLock = threading.RLock() # lock to synchronize access to the serial port comms self.ModbusStartTime = datetime.datetime.now() # used for com metrics # log errors in this module to a file self.log = mylog.SetupLogger("mymodbus", self.loglocation + "mymodbus.log")
def __init__(self, monitor=False, incoming_folder=None, processed_folder=None, incoming_callback=None, localinit=False): 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 self.Mailbox = 0 self.EmailSendQueue = [] # queue for email to send # log errors in this module to a file if localinit == True: logfile = "mymail.log" configfile = "mymail.conf" else: logfile = "/var/log/mymail.log" configfile = "/etc/mymail.conf" self.log = mylog.SetupLogger("mymail", logfile) atexit.register(self.Cleanup) try: config = ConfigParser.RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read(configfile) self.EmailPassword = config.get('MyMail', 'email_pw') self.EmailAccount = config.get('MyMail', 'email_account') self.EmailRecipient = config.get('MyMail', 'email_recipient') self.SMTPServer = config.get('MyMail', 'smtp_server') self.IMAPServer = config.get('MyMail', 'imap_server') self.SMTPPort = config.getint('MyMail', 'smtp_port') except Exception, e1: self.FatalError("ERROR: Unable to read config file" + str(e1))
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 = mylog.SetupLogger("client", "/var/log/myclient.log") self.console = mylog.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 = myclient.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.MyThread( self.MainPollingThread, Name="PollingThread") except Exception as e1: self.LogErrorLine("Error in mynotify init: " + str(e1))
def __init__(self, port="/dev/ttyAMA0", rate=115200, loglocation="/var/log/", log=None, localinit=False, ConfigFilePath=None, 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 = "/etc/" else: self.ConfigFilePath = ConfigFilePath # log errors in this module to a file if localinit == True: self.configfile = "mymodem.conf" else: self.configfile = self.ConfigFilePath + "mymodem.conf" # log errors in this module to a file if log == None: self.log = mylog.SetupLogger("mymodem", loglocation + "mymodem.log") else: self.log = log self.console = mylog.SetupLogger("mymodem_console", log_file="", stream=True) try: self.config = myconfig.MyConfig(filename=self.configfile, section="MyModem", log=self.log) if self.config.HasOption('log_at_commands'): self.LogAtCommands = self.config.ReadValue('log_at_commands', return_type=bool) else: self.LogAtCommands = False if self.config.HasOption('message_level'): self.MessageLevel = self.config.ReadValue('message_level') else: self.MessageLevel = "error" if self.config.HasOption('rate'): self.Rate = self.config.ReadValue('rate', return_type=int) else: self.Rate = rate if self.config.HasOption('port'): self.Port = self.config.ReadValue('port') else: self.Port = port if self.config.HasOption('recipient'): self.Recipient = self.config.ReadValue('recipient') else: self.Recipient = recipient if self.config.HasOption('modem_type'): self.ModemType = self.config.ReadValue('modem_type') else: self.ModemType = modem_type except Exception as e1: self.LogErrorLine("Error reading config file: " + str(e1)) self.LogConsole("Error reading config file: " + str(e1)) return # rate * 10 bits then convert to MS self.CharacterTimeMS = (((1 / self.Rate) * 10) * 1000) self.InitComplete = False try: self.SerialDevice = myserial.SerialDevice(port, rate=rate, loglocation=loglocation, log=self.log) self.Threads = self.MergeDicts(self.Threads, self.SerialDevice.Threads) self.Threads["SendMessageThread"] = mythread.MyThread( self.SendMessageThread, Name="SendMessageThread") except Exception as e1: self.LogErrorLine("Error opening serial device in MyModem: " + str(e1))
body = Message) print(message.sid) except Exception as e1: log.error("Error: " + str(e1)) print ("Error: " + str(e1)) #------------------- Command-line interface for gengpio -----------------# if __name__=='__main__': # usage program.py [server_address] address='127.0.0.1' if len(sys.argv)<2 else sys.argv[1] # Set the signal handler signal.signal(signal.SIGINT, signal_handler) try: log = mylog.SetupLogger("client", "/var/log/gensms.log") # read config file config = configparser.RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read('/etc/gensms.conf') account_sid = config.get('gensms', 'accountsid') auth_token = config.get('gensms', 'authtoken') to_number = config.get('gensms', 'to_number') from_number = config.get('gensms', 'from_number') GenNotify = mynotify.GenNotify( host = address, onready = OnReady,
#---------------------ClientInterface::FatalError------------------------ def LogError(self, Message): log.error(Message) #---------- ClientInterface::FatalError --------------------------------- def FatalError(self, Message): log.error(Message) raise Exception(Message) #------------------------------------------------------------ app = Flask(__name__, static_url_path='') # log errors in this module to a file log = mylog.SetupLogger("genserv", "/var/log/genserv.log") #------------------------------------------------------------ @app.route('/') def root(): return app.send_static_file('index.html') #------------------------------------------------------------ @app.route("/cmd/<command>") def command(command): if command in [ "status", "outage", "maint", "logs", "monitor", "getbase", "getsitename", "setexercise", "setquiet", "getexercise"
#------------------- StartTransferCallBack -----------------# def StartTransferCallBack(): try: MyClientInterface.ProcessMonitorCommand( "generator: setremote=starttransfer") except Exception as e1: log.error("Error: " + str(e1)) #------------------- Command-line interface for gengpioin -----------------# if __name__ == '__main__': # usage program.py [server_address] address = '127.0.0.1' if len(sys.argv) < 2 else sys.argv[1] try: log = mylog.SetupLogger("client", "gengpioin.log") # Set the signal handler signal.signal(signal.SIGINT, signal_handler) MyClientInterface = myclient.ClientInterface(host=address, log=log) #setup GPIO using Board numbering GPIO.setmode(GPIO.BOARD) print GPIO.RPI_INFO GPIO.setwarnings(True) GPIO.setup( INPUT_STOP, GPIO.IN, pull_up_down=GPIO.PUD_UP) # input, set internal pull up resistor#
def LoadConfig(): global log global clientport global loglocation global bUseSecureHTTP global HTTPPort global HTTPAuthUser global HTTPAuthPass global SSLContext global favicon HTTPAuthPass = None HTTPAuthUser = None SSLContext = None try: config = RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read(GENMON_CONFIG) # heartbeat server port, must match value in check_generator_system.py and any calling client apps if config.has_option('GenMon', 'server_port'): clientport = config.getint('GenMon', 'server_port') if config.has_option('GenMon', 'loglocation'): loglocation = config.get("GenMon", 'loglocation') # log errors in this module to a file log = mylog.SetupLogger("genserv", loglocation + "genserv.log") if config.has_option('GenMon', 'usehttps'): bUseSecureHTTP = config.getboolean('GenMon', 'usehttps') if config.has_option('GenMon', 'http_port'): HTTPPort = config.getint('GenMon', 'http_port') if config.has_option('GenMon', 'favicon'): favicon = config.get('GenMon', 'favicon') # user name and password require usehttps = True if bUseSecureHTTP: if config.has_option('GenMon', 'http_user'): HTTPAuthUser = config.get('GenMon', 'http_user') HTTPAuthUser = HTTPAuthUser.strip() # No user name or pass specified, disable if HTTPAuthUser == "": HTTPAuthUser = None HTTPAuthPass = None elif config.has_option('GenMon', 'http_pass'): HTTPAuthPass = config.get('GenMon', 'http_pass') HTTPAuthPass = HTTPAuthPass.strip() if bUseSecureHTTP: app.secret_key = os.urandom(12) OldHTTPPort = HTTPPort HTTPPort = 443 if config.has_option('GenMon', 'useselfsignedcert'): bUseSelfSignedCert = config.getboolean('GenMon', 'useselfsignedcert') if bUseSelfSignedCert: SSLContext = 'adhoc' else: if config.has_option('GenMon', 'certfile') and config.has_option( 'GenMon', 'keyfile'): CertFile = config.get('GenMon', 'certfile') KeyFile = config.get('GenMon', 'keyfile') if CheckCertFiles(CertFile, KeyFile): SSLContext = (CertFile, KeyFile) # tuple else: HTTPPort = OldHTTPPort SSLContext = None else: # if we get here then usehttps is enabled but not option for useselfsignedcert # so revert to HTTP HTTPPort = OldHTTPPort except Exception as e1: log.error("Missing config file or config file entries: " + str(e1))
print(message.id) except Exception as e1: log.error("Error: " + str(e1)) print("Error: " + str(e1)) #------------------- Command-line interface for gengpio -----------------# if __name__ == '__main__': # usage program.py [server_address] address = '127.0.0.1' if len(sys.argv) < 2 else sys.argv[1] # Set the signal handler signal.signal(signal.SIGINT, signal_handler) try: log = mylog.SetupLogger("client", "/var/log/genpushover.log") # read config file config = RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read('/etc/genpushover.conf') appid = config.get('genpushover', 'appid') userid = config.get('genpushover', 'userid') pushsound = config.get('genpushover', 'pushsound') GenNotify = mynotify.GenNotify(host=address, onready=OnReady, onexercise=OnExercise, onrun=OnRun,
def __init__(self, monitor=False, incoming_folder=None, processed_folder=None, incoming_callback=None, localinit=False): 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 self.Mailbox = 0 self.EmailSendQueue = [] # queue for email to send self.DisableEmail = False self.SSLEnabled = False # log errors in this module to a file if localinit == True: logfile = "mymail.log" configfile = "mymail.conf" else: logfile = "/var/log/mymail.log" configfile = "/etc/mymail.conf" self.log = mylog.SetupLogger("mymail", logfile) atexit.register(self.Cleanup) try: config = configparser.RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read(configfile) self.EmailPassword = config.get('MyMail', 'email_pw') self.EmailAccount = config.get('MyMail', 'email_account') if config.has_option('MyMail', 'sender_account'): self.SenderAccount = config.get('MyMail', 'sender_account') else: self.SenderAccount = self.EmailAccount self.EmailRecipient = config.get('MyMail', 'email_recipient') # SMTP Server if config.has_option('MyMail', 'smtp_server'): self.SMTPServer = config.get('MyMail', 'smtp_server') self.SMTPServer = self.SMTPServer.strip() else: self.SMTPServer = "" # IMAP Server if config.has_option('MyMail', 'imap_server'): self.IMAPServer = config.get('MyMail', 'imap_server') self.IMAPServer = self.IMAPServer.strip() else: self.IMAPServer = "" self.SMTPPort = config.getint('MyMail', 'smtp_port') if config.has_option('MyMail', 'disableemail'): self.DisableEmail = config.getboolean('MyMail', 'disableemail') if config.has_option('MyMail', 'ssl_enabled'): self.SSLEnabled = config.getboolean('MyMail', 'ssl_enabled') except Exception as e1: self.FatalError("ERROR: Unable to read config file" + str(e1)) atexit.register(self.Cleanup) if not self.DisableEmail: if self.SMTPServer != "": self.threadSendEmail = threading.Thread( target=self.SendMailThread, name="SendMailThread") self.threadSendEmail.daemon = True self.threadSendEmail.start() # start SMTP thread else: self.LogError("SMTP disabled") if monitor and self.IMAPServer != "": # if True then we will have an IMAP monitor thread if incoming_callback and incoming_folder and processed_folder: self.threadEmail = threading.Thread( target=self.EmailCommandThread, name="EmailCommandThread") self.threadEmail.daemon = True self.threadEmail.start() # start IMAP thread else: self.FatalError( "ERROR: incoming_callback, incoming_folder and processed_folder are required if receive IMAP is used" ) else: self.LogError("IMAP disabled")
# the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import datetime, time, sys, smtplib, signal, os, threading, socket import mylog # log errors in this module to a file log = mylog.SetupLogger("client", "client.log") #---------- ClientInterface::init--- ------------------------------------------ class ClientInterface: def __init__(self, host="127.0.0.1", port=9082): self.EndOfMessage = "EndOfMessage" self.rxdatasize = 2000 self.host = host self.port = port self.Connect() #---------- ClientInterface::Connect --------------------------------- def Connect(self):
if opt == '-h': print(HelpStr) sys.exit() elif opt in ("-a", "--address"): address = arg elif opt in ("-f", "--filename"): fileName = arg print 'Address is "', address print 'Output file is "', fileName if not len(fileName): print(HelpStr) sys.exit(2) try: log = mylog.SetupLogger("client", "genlog.log") # Set the signal handler signal.signal(signal.SIGINT, signal_handler) MyClientInterface = myclient.ClientInterface(host=address, log=log) LastEvent = "" while True: data = MyClientInterface.ProcessMonitorCommand( "generator: getbase") if LastEvent != data: LastEvent = data LogDataToFile(fileName, datetime.now(), data)