Recorder.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.3 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC
import logging
import os

class Recorder(object):
  """\brief Recorder class
  
  Base class for the Recorder portion of the monitoring system.
  Recorders send on the data that the Retriever class acquires.
  """
  def __init__(self):
    self.__cachedValues={}
    self.__log=logging.getLogger('monitoring.Recorder')
  
  def updateTrends(self, trendables):
    if trendables is None: return
    for t in trendables:
      self.__cachedValues[t.name]=t
    self.processTrends(trendables)
  
  def processTrends(self, trendables):
    raise NotImplementedError('processTrends(trendables)'\
                              +'must be implemented in a subclass.')

  def shutdown(self):
    pass

class DummyRecorder(Recorder):
  """\brief Example recorder that dumps the trendables to a logger
  """
  def __init__(self):
    Recorder.__init__(self)
    self.__log=logging.getLogger('monitoring.Recorder')
    
  def processTrends(self, trendables):
    for t in trendables: 
      self.__log.info(t)
      
class FlatFileRecorder(Recorder):
  def __init__(self, flatFile):
    Recorder.__init__(self)
    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 shutdown(self):
    self.__flatFile.close()
    
  def __processTrends(self, trendables):
    trendMap  = {}
    # Add the timestamp
    timeStamp = trendables[0].time
    trendMap['TimeStamp'] =timeStamp
    line = ''
    
    for t in trendables:
      trendMap[t.name] = t.content['Raw Value']
    
    for k in self.__keyList:
      line += str(trendMap[k]) + self.__pad
    line += '\n'
    self.__flatFile.write(line)
    self.__flatFile.flush()
      
  def __createFileHeader(self, trendables):
    # 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 UDPRecorder(Recorder):
  """\brief Example recorder that UDP broadcasts trendables
  
  Uses LATTE.tools.DataDistributionServer
  """
  def __init__(self):
    Recorder.__init__(self)
    self.__dds=None
    self.__log=logging.getLogger('monitoring.UDPRecorder')

  def startUDPServer(self,name,server):
    from LATTE.tools.DataDistributor import DataDistributorServer
    self.__log.info("Starting DataDistributorServer %s on %s",name,server)
    self.__dds=DataDistributorServer(name)
    self.__dds.connect(server)

  def stopUDPServer(self):
    if self.__dds:
      self.__log.info('Disconnecting Broadcast Server')
      self.__dds.disconnect()
      self.__dds=None
          
  def processTrends(self,trendables):
    if self.__dds:
      from cPickle import dumps
      # Send to receiver as a binary pickled object
      self.__dds.publish(dumps(trendables,1))
          
  def shutdown(self):
    self.stopUDPServer()

---