AlertGuiImpl.py

#!/usr/local/bin/python
#
#                               Copyright 2002
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "GLAST LAT Alert System GUI"
__author__   = "J. Panetta"
__date__     = "28/01/2005"
__version__  = "$Revision: 1.5 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from LATTE.logger.MSGLogGUIImpl   import *
from LATTE.client.gOptions        import Options
from LATTE.tools.gAlert           import *
from LATTE.logger.socketLogging   import *

from ConfigParser                 import *
from string                       import *


class gAlertPopup(gAlertHandler):
  def __init__(self, gui):
    gAlertHandler.__init__(self)
    self.__gui = gui
    
  def handle(self, alertStr):
    (severity, timestamp, machine, system, message) = alertStr.decode()
    alertHeader = "%s: %s System Alert, HOST:%d" % (alertDict[severity], system, machine)
    
    mb = QMessageBox( alertHeader, message, QMessageBox.Critical, 
                      QMessageBox.Ok, QMessageBox.NoButton, QMessageBox.NoButton,
                      self.__gui, None, False )
    
    mb.show()
    
class AlertGuiImpl(MSGLogGUIImpl):
  def __init__(self, cfg):
    MSGLogGUIImpl.__init__(self)
    self.setCaption("LATTE alerting system")
    self.__registry = gAlertRegistry()
    
    self.config(cfg)

  def handleAlert(self, alertList):
    tempString = join(alertList[5:],' ')
    alertString = gAlertStr(tempString)
    self.__registry.handle(alertString)
    
  def startListenerThread(self):
    self.Logger.clear()
    self.LogType.setText("Active Run Control Log")
    self.LogType.setAlignment(QLineEdit.AlignLeft)

    self.tcpserver = MSGLogSocketReceiver(self, port=ALARM_TCP_LOGGING_PORT)
    self.tcpserver.logname = self._MSGLogGUIImpl__logname
    self.runTCPThread = threading.Thread(target=self.runTCP, name=self.tcpserver.logname, args=(self.tcpserver,))
    self.runTCPThread.start()


  def config(self, configFile):
    parser = ConfigParser()
    parser.read(configFile)
    
    handlers = {}
    alarms   = {}
    
    # test the config for required parameters
    cSect    = parser.sections()
    REQUIRED = ('core', 'handlers', 'alarms')
    for sect in REQUIRED:
      if sect not in cSect:
        msg = 'Config file %s is missing required section: %s' % ( configFile, sect )
        raise KeyError, msg
    
    for section in cSect:
      options = parser.options(section)
      if section == "core":
        # core doesn't do anything ... yet
        pass
      elif section == "handlers":
        for option in options:
          handlers[option] = parser.get(section, option)
      
      elif section == "alarms":
        for option in options:
          alarms[option] = parser.get(section, option)
    
    # parse the handlers out
    for handler in handlers:
      (name, email) = handlers[handler].split(",")
      address = '\"%s\" <%s>' % (strip(name), strip(email))
      handlers[handler] = gAlertMailer(address)     # replace the instance

    for alarm in alarms:
      for handlerString in alarms[alarm].split(","):
        # print "adding handler %s to alarm %s" % (strip(handlerString), alarm)
        self.__registry.register(alarm, handlers[strip(handlerString)])
        
    popupHandler = gAlertPopup(self)
    self.__registry.register("ALL", popupHandler)

def usage():
  return """

AlertGuiImpl Usage:

Mandatory options:
--config    specify the configuration file to read

Example:
$ AlertGuiImpl --config alert.cfg

"""

if __name__ == "__main__":
  
  # Options, first list mandatory, second list optional 
  options = Options(['config'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(usage())
    raise Exception, msg

  a = QApplication(sys.argv)
  QObject.connect(a,SIGNAL("lastWindowClosed()"),a,SLOT("quit()"))
  w = AlertGuiImpl(options.config)
  w.startListenerThread()
  a.setMainWidget(w)
  w.show()
  a.exec_loop()

---