AlarmHandler.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Classes for determining alarm states"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "12/29/2005" # Created
__updated__  = ("$Date: 2006/04/28 01:20:18 $").split(' ')[1]
__version__  = "$Revision: 1.6 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import threading
import sys, os, asyncore
from ConfigParser              import ConfigParser

from qt import QApplication, QMainWindow, QObject
from qt import QPopupMenu, QString, Qt, QColor, QTimer
from qt import SIGNAL, SLOT

# JHP: must construct QApplication before QLV_AlarmedItem
#     (paint object error in QT)
mainApp = QApplication(sys.argv)
killEvent = threading.Event()
killEvent.clear()

from LICOS.core.thread.guiBridges    import GUIbridge
from LICOS.tools.alarm.AlarmWindow   import AlarmWindow
from LICOS.tools.alarm.AlarmObjects  import QLV_AlarmedItem, AlarmClient
from LICOS.tools.alarm.AlarmStates   import AlarmState
from LICOS.tools.proxy.VscProxyPorts import VscProxyPorts
from ISOC.TlmUtils.TlmRdbInterface   import TlmRdbDb


lightGray = QColor(0xd0,0xd0,0xd0)
UPDATE_CHECK_TIME = 20   # seconds


#class Limit(object):
#  def __init__(self ,name=None, desc=None, descLong=None ,version=None, redLo=None, yelLo=None, yelHi=None, redHi=None):
#    self.name = name
#    self.desc = desc
#    self.descLong = descLong
#    self.version = version
#    self.redLo = redLo
#    self.yelLo = yelLo
#    self.yelHi = yelHi
#    self.redHi = redHi


def asyncore_loop(timeout=1.0, use_poll=False, map=None):
  """replace the asyncore central loop and run it its own thread.
     Valid for Python 2.3.x
     Python 2.4 has an extra agument for loop, count.
  """
  if map is None:
      map = asyncore.socket_map

  if use_poll:
    if hasattr(select, 'poll'):
      poll_fun = asyncore.poll3
    else:
      poll_fun = asyncore.poll2
  else:
    poll_fun = asyncore.poll

  while map and not killEvent.isSet():
    poll_fun(timeout, map)


# needs for V 1:
#  3) Alarm window
#  4) Disabled alarm set.
#  5) Record the alarms somewhere???

# Wishes for V 2:
#  1) Expand hierarchy where there are non-green/black items
#  2) If adding mnems multiple times, wire them correctly



class AlarmHandler(AlarmWindow):
  def __init__(self, config, vscConfig, cvtHost,
               popAlarmSwitch = True,
               parent=None, name = None, fl = 0,):
    AlarmWindow.__init__(self, parent, name, fl)

    self.MainAlarmListView.addColumn('Item')
    self.MainAlarmListView.addColumn('Raw Value')
    self.MainAlarmListView.addColumn('Eng Value')
    self.MainAlarmListView.addColumn('Description')
    self.MainAlarmListView.setSorting(0)
    self.MainAlarmListView.setPaletteBackgroundColor(lightGray)

    self.__guiBridge = GUIbridge(threading.currentThread())

    self.__configuration = config
    self.__vscConfig     = vscConfig
    self.__cvtHost       = cvtHost

    self.__alarmItems    = {}
    self.__source        = None
    self.__tlmDb         = None
    self.__cvc           = None

    self.__popAlarmSwitch = popAlarmSwitch
    self.__prevUpdateCounter = -1

    self.connect(self.MainAlarmListView,
                 SIGNAL("contextMenuRequested(QListViewItem *, const QPoint &, int)"),
                 self.contextMenuShow)

    self.buildContextMenu()
    self.__tlmDb, self.__source = self.__initDatabase()

#   set Window caption
    try:
      caption = config.get("GUI","caption")
    except:
      caption = 'Alarm Window'
    self.setCaption(QString(caption))

    self.configure()

    #setup timer
    try:
      delay = int(config.get("timer","delay"))*1000
    except:
      delay = UPDATE_CHECK_TIME * 1000
    self.__timer = QTimer()
    self.__timer.connect(self.__timer, SIGNAL("timeout()"), self.__timerEvent)
    self.__timer.start(delay, False)

  def fileExit(self):
    self.close()

  def close(self, qParam = False):
    self.__guiBridge.shutdown()
    return QMainWindow.close(self, qParam)

  def configuration(self):
    return self.__configuration

  def configure(self):

    # build toplevel gui
    config = self.configuration()
    if not config.has_section('top_level'):
      msg = "Configuration lacks 'top_level' section.  Cannot configure AlarmHandler"
      raise RuntimeError(msg)

    # add the subItems to the top level
    self.__alarmItems['top_level'] = self.MainAlarmListView
    for tlItem in self.__getMembers('top_level'):
      self.addItem(tlItem, 'top_level')

    # Determine valid mnemonics from db
    validMnems = []
    for mnem in self.__alarmItems.keys():
      if mnem not in validMnems and self.__tlmDb.mnem(mnem) is not None:
        validMnems.append(mnem)
        self.__alarmItems[mnem].setDescription(self.__tlmDb.mnem(mnem).desc())

    # wire in CVT
    ports = VscProxyPorts(self.__vscConfig.getint('vsc', 'proxyPortBase'))
    self.__cvc = AlarmClient( host = self.__cvtHost,
                              port = ports.cvtOut(),
                              gui  = self,
                              mnemList = validMnems)
    
    self.optionsAlarm_PopupsAction.setOn(self.__popAlarmSwitch)
    self.__cvc.registerAll()

  def addItem(self, itemName, parentName):
    """!\brief Add an item to the alarm handler.  Recursive.

    \param Name of the item to be added
    """
    config = self.configuration()

    parent = self.__alarmItems[parentName]
    thisItem = QLV_AlarmedItem(self, parent, str(itemName), AlarmState.NoLimit)
    self.__alarmItems[itemName] = thisItem

    if itemName in config.sections():
      if config.has_option(itemName, 'expanded'):
        expanded = config.getboolean(itemName, 'expanded')
        thisItem.setOpen( expanded )
      if config.has_option(itemName, 'description'):
        thisItem.setDescription( config.get(itemName, 'description').strip() )
      thisItem.setRawValue()

      for member in self.__getMembers(itemName):
        self.addItem(member, itemName)
      thisItem.sortChildItems(0, True)


  def __getMembers(self, itemName):
    """!\brief retrieve a list of members of an alarmed hierarchy entry

    """
    config = self.configuration()
    if config.has_option(itemName, 'members'):
      mStr = config.get(itemName, 'members')
      mList = [ a.strip() for a in mStr.split(',') ]
    else:
      mList = []

    return mList

  def alarmItems(self):
    return self.__alarmItems

  def tlmDb(self):
    return self.__tlmDb

  def guiBridge(self):
    return self.__guiBridge

  def contextMenuShow(self, item, pos, col ):
    self.__contextMenu.exec_loop(pos)

  def buildContextMenu(self):
    self.__contextMenu = QPopupMenu(self)
    self.__contextMenu.insertItem("Show Data", self.showData)
#    self.__contextMenu.insertItem("Expand", self.expandChildren)
#    self.__contextMenu.insertItem("Collapse", self.collapseChildren)
    self.__contextMenu.insertItem("Show Limits",self.showLimits)
    self.__contextMenu.insertItem("Acknowledge Alarms", self.acknowledge)
    self.__contextMenu.insertItem("Disable", self.disableAlarm)
    self.__contextMenu.insertItem("Enable", self.enableAlarm)

  def showData(self):
    # Note: selItem is a QLV_AlarmedItem
    selItem = self.MainAlarmListView.selectedItem()
    if selItem is not None:
      selItem.showInfo()

  def showLimits(self):
    # Note: selItem is a QLV_AlarmedItem
    selItem = self.MainAlarmListView.selectedItem()
    if selItem is not None:
      selItem.showLimits()

  def expandChildren(self):
    # Note: selItem is a QLV_AlarmedItem
    selItem = self.MainAlarmListView.selectedItem()
    if selItem is not None:
      selItem.expandChildren(True)

  def collapseChildren(self):
    # Note: selItem is a QLV_AlarmedItem
    selItem = self.MainAlarmListView.selectedItem()
    if selItem is not None:
      selItem.expandChildren(False)

  def acknowledge(self):
    # Note: selItem is a QLV_AlarmedItem
    selItem = self.MainAlarmListView.selectedItem()
    if selItem is not None:
      selItem.recalculate()

  def disableAlarm(self):
    selItem = self.MainAlarmListView.selectedItem()
    selItem.disable()
#   force update
    selItem.setState(selItem.state(),forceUpdate=True)

  def enableAlarm(self):
    selItem = self.MainAlarmListView.selectedItem()
    selItem.enable()
    #force update
    selItem.setState(selItem.state(),forceUpdate=True)

  def customEvent(self, e):
    self.__guiBridge.handleCustomEvent(e)

  def __cfgDb(self, config):
    import psycopg
    dsn = config.get('postgres', 'dsn')
    db  = psycopg.connect(dsn)

    return db

  def __initDatabase(self):
    config = self.__vscConfig

    csect = config.sections()
    sect = "tlmdb"
    if sect not in csect:
      msg = "Config file %s is missing required section: %s" % (config, sect)
      raise KeyError, msg

    source = int(config.get("tlmdb", "source"))
    build  = config.get("tlmdb", "build")

    db = self.__cfgDb(config)
    cur = db.cursor()

    tlmDb = TlmRdbDb(cur)

    tlmDb.populate(source=source, build=build)

    return (tlmDb, source)

  def __timerEvent(self):
    val = self.__cvc.getUpdateCount()
    if val == self.__prevUpdateCounter:
      self.leUpdateCounter.setPaletteBackgroundColor(Qt.red)
    else:
      self.leUpdateCounter.setPaletteBackgroundColor(lightGray)
    self.__prevUpdateCounter = val
    self.leUpdateCounter.setText(QString(str(val)))
    x = self.MainAlarmListView.sizeHint()

  def optionsAlarmPopups(self, state):
    if state:
      self.__popAlarmSwitch = True
    else:
      self.__popAlarmSwitch = False

  def popAlarms(self):
    # Return True or False depending on whether popup alarms are active
    return self.__popAlarmSwitch


def main(options):
  # mainApp is defined in include region at start of file.

  config = ConfigParser()
  config.read(options.config)

  vscConfig = ConfigParser()
  vscConfig.read(options.vscConfig)

  cvtHost    = options.cvtHost

  #check for no Popup Alarm Box switch
  if options.noPopAlarm is None:
    popAlarmSwitch = True
  else:
    popAlarmSwitch = False

  p = AlarmHandler(config, vscConfig, cvtHost, popAlarmSwitch)
  mainApp.setMainWidget(p)

  p.show()
  QObject.connect(mainApp, SIGNAL("lastWindowClosed()"), mainApp, SLOT("quit()"))
  # start the asyncore loop.  Termination is set by killEvent
  threading.Thread(target=asyncore_loop).start()

  mainApp.exec_loop()
  killEvent.set()

def usage():
  s = '/'
  if os.name == 'nt':  s = '\\'
  name = sys.argv[0].split('.')[-2].split(s)[-1]
  return "%s is used to display telemetry data from a database." % (name)



if __name__ == '__main__':

  from LICOS.util.gOptions import Options

  options = Options(['config', 'vscConfig', 'cvtHost'],switches = ['noPopAlarm'])
  try:
   options.parse()
  except Exception, msg:
   options.usage(usage())
   raise Exception, msg
  x = options.noPopAlarm

  main(options)

---