Receiver.py

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

__facility__ = "Online"
__abstract__ = "Housekeeping receiver module"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "7/20/2004"
__version__  = "$Revision: 1.2 $"
__credits__  = "SLAC"


import LATTE.copyright_SLAC

from LATTE.monitoring.Trendable import Trendable
import logging

class Receiver(object):
  """\brief Abstract Receiver class

  Receiver objects retrieve the trendable data from some location.
  """
  def __init__(self):
    self.log=logging.getLogger('monitoring.Receiver')
    self.__loopStop=0
    self.__recThread=None

  def isReceiving(self):
    if self.__monThread: return 1
    else: return 0

  def setReceiving(self,bool):
    if bool: self.__startLoop()
    else: self.__stopLoop()

  def shutdown(self):
    self.setReceiving(0)

  def receive(self):
    raise NotImplementedError('receive()' \
                              +'must be implemented in a subclass.')

  def process(self,trendables):
    for t in trendables:
      self.log.info(t)

##private
  def __startLoop(self):
    if not self.__recThread:
      from threading import Thread
      self.__recThread=Thread(None,self.__recLoop,'ReceiverLoop')
      self.__recThread.start()
    else:
      self.log.warning('Already a ReceiverLoop Running')

  def __stopLoop(self):
    if self.__recThread:
      self.__loopStop=1
      self.__recThread.join()
      self.loopStop=0
      self.__recThread=None

  def __recLoop(self):
    self.log.info('Starting Receive Loop')
    while (not self.__loopStop):
      self.receive()
    self.log.info('Receive Loop Stopped')

class UDPReceiver(Receiver):
  """\brief UDPReceiver class
  """
  tType = (Trendable('InvalidName', 0))
  def __init__(self):
    Receiver.__init__(self)
    self.__ddc=None
    self.log=logging.getLogger('monitoring.UDPReceiver')

  def receive(self):
    if self.__ddc:
      from cPickle import loads
      d,s=self.__ddc.receive()
      if not d: return
      trendables=loads(d)
      for t in trendables:
        if not isinstance(t,type(self.tType)):
          self.log.error('Data received is not a Trendable')
          trendables.remove(t)
      self.process(trendables)

  def setUDPClient(self,name,server):
    from LATTE.tools.DataDistributor import DataDistributorClient
    self.log.info('Connecting to DataDistributorServer %s on %s',
                    name,server)
    #self.__ddc=DataDistributorClient(name,length=40960)
    self.__ddc=DataDistributorClient(name)
    self.__ddc.connect(server)

  def shutdown(self):
    if self.__ddc:
      self.__ddc.returnNone()
    self.setReceiving(0)
    if self.__ddc:
      self.log.info('Disconnecting from DataDistributorServer')
      self.__ddc.disconnect()
      self.__ddc=None

---