HskCollector.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__     = "10/06/04"
__version__  = "$Revision: 1.8 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import logging as log
import logging.handlers
import sys

# base classes
from LATTE.monitoring.Collector    import Collector
from ConfigParser                  import *

from LATTE.client.gCmdCli          import CmdCli
from LATTE.database.gLAT           import GLAT
from LATTE.database.gHSK           import GHSK
from LATTE.monitoring.HskCli       import *
from LATTE.logger.socketLogging    import socketLogging
from LATTE.tools.gAlert            import *


class HskConfiguration(ConfigParser):
  """
  """
  def __init__(self):
    ConfigParser.__init__(self)
    self.__fileName = None
  
  def read(self, fileName):
    self.__fileName = fileName
    ConfigParser.read(self, fileName)
    
  def verify(self):
    # test the config for required parameters
    cSect    = self.sections()
    REQUIRED = ('core', 'database', 'inputs')
    for sect in REQUIRED:
      if sect not in cSect:
        msg = 'Config file %s is missing required section: %s' % ( self.__fileName, sect )
        raise KeyError, msg
    
    # core check
    coItems  = self.options('core')
    REQUIRED = ('loghost',)
    for item in REQUIRED:
      if item not in coItems:
        msg = 'Config file %s is missing required key %s in core section' % ( self.__fileName, item )
        raise KeyError, msg
    
    # database check
    dbItems  = self.options('database')
    REQUIRED = ('type',)
    for item in REQUIRED:
      if item not in dbItems:
        msg = 'Config file %s is missing required key %s in database section' % ( self.__fileName,item )
        raise KeyError, msg
    
    # inputs check
    inItems  = self.options('inputs')
    REQUIRED = ('latschema', 'hskschema', 'server', 'packet')
    for item in REQUIRED:
      if item not in inItems:
        msg = 'Config file %s is missing required key %s in inputs section' % ( self.__fileName, item )
        raise KeyError, msg
    

class HskCollector(Collector):
  """\brief Configurable housekeeping collector
  
  Takes a HskConfiguration object as input.
  """
  def __init__(self, config):
    Collector.__init__(self)
    
    # connect to the message logger and configure logging.
    logHost = config.get('core', 'loghost')
    if logHost is not "None":
      # Needs to be done before the first call to log
      if config.has_option('core', 'loglevel'):
        # Logger has levels like DEBUG CRITICAL, etc.  must be upper
        logLevel = config.get('core', 'loglevel').upper()
      else:
        logLevel = "DEBUG"
      socketLogging(logHost, logLevel)

    # Required inputs.  Checked in setup of configuration
    latSchema = config.get('inputs', 'latSchema')
    hskSchema = config.get('inputs', 'hskSchema')
    cmdServer = config.get('inputs', 'server')
    
    
    # set up command client
    self.__cmdCli     = CmdCli()
    self.__cmdHandler = HskHandler(self.__cmdCli, cmdServer)
    
    # set up LAT database (Needed for commanding)
    self.__latDB = GLAT(self.__cmdCli)
    self.__latDB.readSchema(latSchema)
    
    # set up HSK database
    self.__hskDB      = GHSK(self.__cmdCli)
    self.__hskDB.readSchema(hskSchema)
    self.__hskDB.applyConfig(None)
    
    # Delay setting is optional, default = 10 seconds
    try:
      self.setDelay(config.getint('core', 'delay'))
    except:
      pass
    
    # set up retrievers
    if config.getboolean('inputs', 'packet'):
      # HskPacket reads
      log.debug("Adding HskPacketRetriever to HSK fabric")
      from LATTE.monitoring.HskCli             import HskCli
      from LATTE.monitoring.HskPacketRetriever import HskPacketRetriever
      self.__hskCli     = HskCli()
      self.__hskHandler = HskHandler(self.__hskCli, cmdServer)
      self.addRetriever( "HSK", HskPacketRetriever(self.__hskCli) ) 
      # no delay in packetized housekeeping.  Camp on the connection.
      self.setDelay(0)
    else:
      # LAT single register reads
      log.debug("Adding HskLatRetriever to HSK fabric")
      from LATTE.monitoring.HskRetriever       import HskLatRetriever
      self.addRetriever( "HSK", HskLatRetriever(self.__latDB) )

    # set up recorders:
    # Alarming system
    from LATTE.monitoring.HskRecorder          import HskAlarmRecorder
    self.addRecorder( HskAlarmRecorder(self.__hskDB) )
    
    # Systems to write data out
    if config.get('database', 'type') == 'sql':
      # set up SQL recorder
      log.debug("Attempting to add HskSqlRecorder to HSK fabric")
      import MySQLdb
      from LATTE.monitoring.HskSqlInterface   import HskSqlRecorder
      host = config.get('database', 'host')
      user = config.get('database', 'user')
      src  = config.getint('database', 'machineid')
      
      log.debug("Connecting to database on %s" % host)
      sqlDB = MySQLdb.connect(host=host, db='itosdb', user=user)
      self.addRecorder(HskSqlRecorder(self.__hskDB, sqlDB.cursor(), src))
    else:
      # text/flatfile database
      log.debug("Attempting to add HskFileRecorder to HSK fabric")
      dataFile = config.get('database', 'datafile')
      from LATTE.monitoring.HskRecorder       import HskFileRecorder
      self.addRecorder(HskFileRecorder(self.__hskDB, dataFile))
    
    # optional UDP broadcast
    if config.has_section('udp') & config.getboolean('udp', 'broadcast'):
      log.debug("Attempting to add UDPRecorder to HSK fabric")
      from LATTE.monitoring.Recorder          import UDPRecorder
      serverName = config.get('udp', 'serverName')
      serverAddr = config.get('udp', 'serverAddr')

      udpR = UDPRecorder()
      udpR.startUDPServer(serverName,serverAddr)
      self.addRecorder(udpR)
    
    # alert("test alert 1 from hsk system", "LATTE")

  def latDB(self): return self.__latDB
  def hskDB(self): return self.__hskDB

---