AlertGuiImpl.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
#                               Copyright 2005
#                                     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__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2005/10/13 03:12:35 $"
__version__  = "$Revision: 1.6 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from LICOS.tools.logger.MSGLogGUIImpl import *
from LICOS.util.gOptions              import Options
from LICOS.util.gAlert                import *
from LICOS.tools.logger.socketLogging import *

from ConfigParser                     import *
from string                           import *


class gAlertPopup(gAlertHandler):
  """!\brief Popup class for alerts.

  """
  def __init__(self, gui):
    """!\brief gAlertPopup constructor.

    \param gui Alert GUI
    """
    gAlertHandler.__init__(self)
    self.__gui = gui

  def handle(self, alertStr):
    """!\brief Handle the alert.

    \param alertStr Alert string
    """
    (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):
  """!\brief Alert GUI class

  """
  def __init__(self, cfg):
    """!\brief AlertGuiImpl constructor

    \param cfg Configuration file
    """
    MSGLogGUIImpl.__init__(self)
    self.setCaption("LICOS alerting system")
    self.__registry = gAlertRegistry()

    self.config(cfg)

  def handleAlert(self, alertList):
    """!\brief Handle the alert.

    \param alertList List of alerts
    """
    tempString = join(alertList[5:],' ')
    alertString = gAlertStr(tempString)
    self.__registry.handle(alertString)

  def startListenerThread(self):
    """!\brief Start the listener thread.

    """
    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):
    """!\brief Parse the configuration file \a configFile

    \param configFile Configuration filename
    """
    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():
  """!\brief Return usage

  \return Usage string
  """
  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()

---