HskRecorder.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.Recorder     import Recorder
from LATTE.database.gHSK           import GHSK
from LATTE.monitoring.TrendMaps    import GHSKTrendMap
import logging as log

class HskAlarmRecorder(Recorder):
  """Applys the trends to the housekeeping node structure.
     As alarms are part of the node structure, we get those for
     free.
  """
  def __init__(self, ghsk):
    Recorder.__init__(self)
    self.__ghsk = ghsk
    self.__trendMap = GHSKTrendMap(ghsk)
    
  def processTrends(self, trendables):
    if trendables is None: return
    for t in trendables:
      key   = t.name
      value = t.content['Raw Value']
      tuple = self.__trendMap.mapGet(key)
      if tuple is not None:
        node, attr = tuple
        if node is not None:
          if  attr != '' and attr is not None:
            node.regs[attr.lower()].set(value, bypass=True)
          elif isinstance(node, str):
            pass
      
class HskFileRecorder(Recorder):
  """Writes the Hsk EGUs to a flat file for later retrieval.
  """
  def __init__(self, ghsk, flatFile):
    Recorder.__init__(self)
    self.__ghsk = ghsk
    self.__trendMap = GHSKTrendMap(ghsk)
    self.__flatFile = open(flatFile, 'a+')
    
    keyList         = self.__flatFile.readline()
    if keyList == '':  # No file, 
      self.processTrends = self.__createFileHeader
    else:
      # create a list of keys from whitespace separated text blobs
      self.__keyList = keyList.split()
      self.processTrends = self.__processTrends
    self.__flatFile.seek(0,2)
    self.__pad = '   '

  def __processTrends(self, trendables):
    if trendables is None: return
      
    from TrendMaps import makeSimpleMap
    trendMap  = makeSimpleMap(trendables, self.__trendMap)
         
    line = ''
    for k in self.__keyList:
      if k in trendMap:
        line += str(trendMap[k]) + self.__pad
      else:
        line += "None     " + self.__pad
    line += '\n'
    self.__flatFile.write(line)
    self.__flatFile.flush()

  def __createFileHeader(self, trendables):
    if trendables is None: return
    # 1: reset function pointer to processTrends
    self.processTrends = self.__processTrends
    # 2: create the sorted key list
    self.__keyList     = []
    for t in trendables:
      self.__keyList.append(t.name)
    self.__keyList.sort()
    self.__keyList.insert(0, 'TimeStamp')
    line = ''
    # 3: write the index line of the file:
    for k in self.__keyList:
      line += (k + self.__pad)
    line += '\n'
    self.__flatFile.writelines([line])
    # 4: Profit!
    self.processTrends(trendables)
    
class HskPacketRecorder(Recorder):
  def __init__(self, ghsk, flatFile):
    Recorder.__init__(self)
    self.__ghsk = ghsk
    self.__trendMap = GHSKTrendMap(ghsk)
    self.__flatFile = open(flatFile, 'a+')
    self.__flatFile.seek(0,2)
    self.__pad = '   '
    
  def processTrends(self, trendables):
    if trendables is None: return
    trendMap  = {}
    # Add the timestamp
    timeStamp = trendables[0].time
    trendMap['TimeStamp'] =timeStamp
    line = ''
    
    line += 'TimeStamp' + ':' + str(timeStamp) + self.__pad
    
    for t in trendables:
      key    = t.name
      tuple  = self.__trendMap.mapGet(key)
      if tuple is not None:
        node, attr = tuple
        if node is not None and attr != '':
          value = node.regs[attr.lower()].get(bypass=False)
          raw = node.regs[attr.lower()].get(bypass=True)
      
          line += key + ':' + str(value) + self.__pad
    line += '\n'
    self.__flatFile.write(line)
    self.__flatFile.flush()

---