HskSqlSvr.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.4 $"
__release__  = "$Name: P04-06-05 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC
import logging as log
import MySQLdb

# Hsk core code
from LATTE.monitoring.HskRetriever import *
from LATTE.monitoring.HskCollector import *
from LATTE.monitoring.HskCli       import HskCli, HskHandler

# LATTE infrastructure
from LATTE.client.gCmdCli          import CmdCli
from LATTE.database.gLAT           import GLAT
from LATTE.database.gHSK           import GHSK
from LATTE.client.gOptions         import Options

latSchema = None
hskSchema = None
comSchema = None
cmdServer = None

def startup():
  log.basicConfig()
  log.root.setLevel(log.DEBUG)

  
def testCollector(sqlDB):
  
  # set up command/housekeeping clients
  cmdCli = CmdCli()
  # hskCli = HskCli()
  # set up command/hsk connection handlers
  cmdHandler = HskHandler(cmdCli, cmdServer)
  # hskHandler = HskHandler(hskCli, cmdServer)
    
  # set up LAT schema
  latDB = GLAT(cmdCli)
  latDB.readSchema(latSchema)
  
  # set up HSK schema
  hskDB = GHSK(cmdCli)
  hskDB.readSchema(hskSchema)
  hskDB.applyConfig(None)
  
  # set up CMD schema
  cmdDB = GLAT(cmdCli)
  cmdDB.readSchema(cmdSchema)
  
  alarmSetup(hskDB, cmdDB)
  
  collector = HskCollector(cmdCli)
  collector.setDelay(501)           # 5 second delay
  
  from HskRetriever import HskLatRetriever
  firstRetriever = HskLatRetriever(latDB)
  collector.addRetriever("HSK", firstRetriever)
  
  from LATTE.monitoring.HskRecorder import HskAlarmRecorder
  firstRecorder = HskAlarmRecorder(hskDB)
  collector.addRecorder(firstRecorder)
  
  from LATTE.monitoring.HskSqlInterface import HskSqlRecorder
  secondRecorder = HskSqlRecorder(hskDB, sqlDB, source=1)
  collector.addRecorder(secondRecorder)
  
  
  log.info( "Collector delay: " + str(collector.getDelay()/10) + " seconds" )
  collector.setAcquiring(True)
  
  from time import sleep
  try:
    while 1:
      sleep(.1)
  except Exception, e:
    collector.shutdown()
  
  cmdHandler.disconnect()
  hskHandler.disconnect()


def alarmSetup(hskDB, cmdDB):
  # Retrieve the global rule list for HSK
  ruleSet = hskDB.getRules()
  # print ruleSet
  # Access any of the rule objects and call clearAllActions() to clear actions.
  ruleSet.values()[0].clearAllActions()
  
  # add some trivial yellow/red alarms
  from HskAlarms import yellowPrintMessage, redPrintMessage
  ruleSet['tempMonitor'].registerAction('yellowAction', yellowPrintMessage)
  # ruleSet['tempMonitor'].registerAction('redAction',    redPrintMessage)

def usage():
  return """

HskSvr Usage:

Mandatory options:
--server    specify the hostname or the IP address of the teststand crate
            to connect to.
--latSchema specify the LAT schema file that defines the detector.
--hskSchema specify the Housekeeping schema file to load.

Optional options:
--cmdSchema specify the LAT schema file to be used for commanding.
            Default is to use latSchema

Example:
$ HskSvr --server lat-elf1 --latSchema LAT.xml  --hskSchema HSK.xml  --cmdSchema LAT.xml

"""
  
if __name__ == '__main__':
  
  startup()
  
  # Options, first list mandatory, second list optional 
  options = Options(['server', 'latSchema', 'hskSchema', 'sqlHost'],
                    ['cmdSchema',])
  try:
    options.parse()
  except Exception, msg:
    options.usage(usage())
    raise Exception, msg
  
  cmdServer = options.server
  latSchema = options.latSchema
  hskSchema = options.hskSchema
  if options.cmdSchema is not None:
    cmdSchema = options.cmdSchema
  else:
    cmdSchema = latSchema
  
  sqlDb = MySQLdb.connect(host=options.sqlHost, db='itosdb', user='itosdb')

  testCollector(sqlDb.cursor())
  
  
  
  
  
  
  
  
  

---