HskSqlGuiReceiver.py

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

__facility__ = "Online"
__abstract__ = "GLAST LAT Housekeeping server infrastructure"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T"
__date__     = "07/28/04"
__version__  = "$Revision: 1.7 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

# from LATTE.monitoring.HskReceiver import HskCfgTextReceiver
from LATTE.client.gOptions            import Options
from LATTE.monitoring.HskSqlInterface import HskSqlReceiver

import logging
import sys
import time
import qt
from   sihippo                        import Observer
import sihippo
import MySQLdb

second  = 1
minute  = 60 * second
hour    = minute * 60
day     = hour * 24
era     = 10**9

timeFmt      = '%H:%M:%S'
dataFile     = None
timeDepth    = 2*hour

sqlDatabase  = None
dataSource   = None

class QtReceiver(qt.QObject, HskSqlReceiver):

  class TrendUpdateEvent(qt.QCustomEvent):
    def __init__(self,trendMap):
      qt.QCustomEvent.__init__(self,qt.QEvent.MaxUser-20)
      self.trendMap = trendMap

  def __init__(self, sqlDB, timeDepth, trendList):
    HskSqlReceiver.__init__(self, sqlDB, timeDepth, trendList)
    qt.QObject.__init__(self)

  def process(self,trendMap):
    qt.QApplication.postEvent(self,QtReceiver.TrendUpdateEvent(trendMap))

  def customEvent(self,event):
    self.emit(qt.PYSIGNAL('TrendUpdate(trendMap)'),(event.trendMap,))



class TrendPlotter(qt.QWidget):
  def __init__(self, keyList, depth, *args):
    qt.QWidget.__init__(self,*args)

    self.__ntuples       = {}
    self.__plots         = {}
    self.__views         = {}
    self.__gen           = {}
    self.__defaultDepth  = depth                 # assuming 1 hz data rate
    self.__defaultLabels = ['Time','']

    self.__dynamic       = True
    self.__keyList       = keyList

    self.grid            = qt.QGridLayout(self,3,2)
    self.grid.setAutoAdd(1)
    self.true            = True

  def isDynamic(self):
    return self.__dynamic
  def setDynamic(self,bool):
    self.__dynamic=bool

  def addPlot(self, key):
    labels  = self.__defaultLabels
    depth   = self.__defaultDepth
    name    = self.__keyList[key]

    # Create the Circular buffer to store the data
    ntc     = sihippo.NTupleController.instance()
    nt      = ntc.createCircularBuffer(labels)
    nt.reserve(depth)
    nt.setTitle(name)
    nt.setName(name)

    # Create the Plot
    dc      = sihippo.DisplayController.instance()
    plot    = dc.createDisplay('XY Plot', nt, labels)
    # plot    = dc.createDisplay('Strip Chart',nt,labels)

    # kludge so that the range is initialized, and autoscales when we need.
    plot.setRange('x',0,1)
    plot.setAutoRanging('x',True)

    # Add the time axis observer
    gen     = TimeAxisGen()
    gen.setPlotter(plot, key)
    plot.addObserver(gen)

    # Add the plot to the screen
    view    = sihippo.QtViewWidget(self)
    view.setPlotter(plot)
    view.setDoubleBuffering(1)
    view.resize(200,100)
    view.setMinimumSize(qt.QSize(100,50))
    # self.grid.addWidget(view)
    view.show()

    # Maintain a reference to the created objects to prevent garbage collection
    self.__ntuples[key]  = nt
    self.__plots[key]    = plot
    self.__views[key]    = view
    self.__gen[key]      = gen

  def update(self, trendMap):
    # if not self.true: return
    self.true=False
    # trendMap has timestamp, val1, val2, val3...
    timeStamp = trendMap['TimeStamp']
    for key in trendMap:
      if key == 'TimeStamp': continue
      if key not in self.__views.keys() and self.__dynamic:
        self.addPlot(key)
      if key not in self.__views.keys():
        return
      x=timeStamp
      y=trendMap[key]
      if y is None:
        continue
      self.__ntuples[key].addRow([x,y])

class TimeAxisGen ( Observer ) :
  __labelFmt   = '%Y/%m/%d'
  __tickFmt    = '%H:%M'
  __dayFmt     = '%m/%d %H:%M'
  __stepSet    = [ 1*second, 5*second, 10*second, 30*second,
                   1*minute, 2*minute, 5*minute, 10*minute, 15*minute, 20*minute, 30*minute,
                   1*hour, 2*hour, 6*hour, 12*hour,
                   1*day, 2*day, 7*day, 30*day, 90*day, 180*day, 364*day,
                   era]

  def setPlotter ( self, plotter, name ) :
    self.plotter = plotter
    self.name    = name
    self.__goodStep = 0

  def update ( self, obs ) :
    # return
    lowTime = self.plotter.getLowRangeOnX()
    highTime = self.plotter.getHighRangeOnX()

    if ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep]) < 1:
      # print "reset of goodStep", self.name, self.__goodStep , highTime, lowTime,  ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep])
      self.__goodStep -= 1
    if ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep]) > 6:
      # print self.name, highTime, lowTime,  ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep])
      step = 0
      while ((highTime - lowTime)/TimeAxisGen.__stepSet[step]) > 5:
        # print "step:", step
        step += 1
      self.__goodStep = step
    step = TimeAxisGen.__stepSet[self.__goodStep]
    if step < 1*day:
      tickFmt = TimeAxisGen.__tickFmt
    else:
      tickFmt = TimeAxisGen.__dayFmt

    lowTick = lowTime - (lowTime % step) + step
    values = []
    values.append( lowTick )

    labels = []
    labels.append( time.strftime(tickFmt, time.localtime(lowTick)) )
    tick = lowTick
    tick += step
    while tick < highTime:
      values.append ( tick )
      labels.append ( time.strftime(tickFmt, time.localtime(tick)) )
      tick += step

    self.plotter.setAutoTicksOnX( False )
    self.plotter.setTicksOnX( values, labels )

    # REALLY REALLY don't do this:
    #   setLabel calls "notifyObservers", which brings us back here...
    # xlabel = time.strftime(TimeAxisGen.__labelFmt, time.localtime(highTime))
    # self.plotter.setLabel( 'x', xlabel )

def memget():
  import win32pdh
  hq = win32pdh.OpenQuery()
  # ch = win32pdh.AddCounter(hq, "\\\\gitow1\\Process(python)\\Private Bytes")
  ch = win32pdh.AddCounter(hq, "\\\\gitow1\\Process(python#1)\\Private Bytes")
  win32pdh.CollectQueryData(hq)
  type, val =win32pdh.GetFormattedCounterValue(ch,win32pdh.PDH_FMT_LONG)
  return val

def startup():
  # print memget()
  logging.basicConfig()
  logging.root.setLevel(logging.DEBUG)

def startQT(sqlDB, timeDepth, keyList, source):
  import sys

  app=qt.QApplication(sys.argv)
  r=QtReceiver(sqlDB, timeDepth, keyList.keys())
  r.setSource(source)

  gui=TrendPlotter(keyList, timeDepth/5)
  gui.connect(r,qt.PYSIGNAL('TrendUpdate(trendMap)'),gui.update)

  app.connect(app,qt.SIGNAL("lastWindowClosed()"),
              app,qt.SLOT("quit()"))

  app.setMainWidget(gui)
  gui.show()

  r.setReceiving(1)
  app.exec_loop()
  r.shutdown()


def configParse(configFile):
  global sqlDatabase, dataSource
  from ConfigParser import ConfigParser
  parser = ConfigParser()
  parser.read(configFile)

  # test the config for required parameters
  cSect    = parser.sections()
  if "database" not in cSect:
    msg = 'Config file %s is missing required section: %s' % ( configFile, "database" )
    raise KeyError, msg

  if parser.get('database', 'type') != 'sql':
    msg = 'HskSqlGuiReceiver requires a connection to an SQL database.\nPlease check your config file'
    raise KeyError, msg

  host        = parser.get('database', 'host')
  user        = parser.get('database', 'user')
  sqlDatabase = MySQLdb.connect(host=host, db='itosdb', user=user)

  dataSource  = parser.getint('database', 'machineid')


def usage():
  return """

HskGuiReceiver Usage:

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

Optional options:
--timeDepth define the time depth of the housekeeping plots.  Default is 2 hours.
            Units are in seconds
--keyFile   define the file of variables to plot
            Note: keyFile format is "KEY  :  Plot title"

Example:
$ HskGuiReceiver --dataFile c:\TEMP\lat-elf11.dat --timeDepth 3600 --keyFile keys.dat

"""


if __name__ == '__main__':
  startup()

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

  if options.timeDepth is not None:
    timeDepth = int(options.timeDepth)
  else:
    timeDepth = 2*hour

  if options.keyFile is not None:
    keyFile = options.keyFile
    from HskReceiver import parseKeyFile
    keyList = parseKeyFile(keyFile)
  else:  # really really basic set of histos.
    keyList = {'LHKADAB33V'   :'AEM DAQ board 3.3 V',
               'LHKAEMFR11T'  :'AEM Free board 11 Temp',
               'LHKADABTEMP'  :'AEM DAQ board Temp',
               'LHKAEMFR11V1' :'AEM Free 11 HV 1',
               'LHKAEMFR11V2' :'AEM Free 11 HV 2',
               'LHKAEMFR11VD' :'AEM Free 11 VDD',
               }

  configParse(options.config)

  startQT(sqlDatabase.cursor(), timeDepth, keyList, dataSource)

---