DataDistributorPoll.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "GLAST LAT data distribution polling class"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2005/09/22 00:29:31 $"
__version__  = "$Revision: 1.5 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC


import DataDistributor as DD
import threading
import copy
import time


class DataDistributorPoll(DD.DataDistributorClient):
  """!\brief Data distributor client that polls for samples of data.

  Use of this class involves the starting of a thread that constantly receives
  the data arriving in the base class's socket.  Keeping the socket drained of
  data allows the user of this class to get the most recent data received, thus
  avoiding getting data with a bursty time structure.  Whenever the application
  calls the receive() method, it gets the most recent data sample.  Because of
  the reference counting method used by Python objects, no copy of the data
  needs to be made to avoid the data changing from underneath the application.
  The application can hold onto the data reference as long as it likes.
  Whenever new data appears a new reference is created, and is possibly deleted
  before the application gets access to it, leaving any existing reference
  alone.  When the application tries to get access to the latest data, it gets
  a copy of the most recent reference, and the previous reference is deleted,
  if it has gone out of scope.
  """
  def __init__(self, name, length = 64*1024):
    """!\brief DataDistributorPoll constructor.

    \param name   The name of the type of data that the client wants to receive.
                  See the DataDistributorAddress class.
    \param length The size in bytes of the buffer to allocate for receiving the
                  data.  Defaults to 64 KB.
    """
    DD.DataDistributorClient.__init__(self, name, length)
    self.__pollTaskQuit = False
    self.__pollTask     = None
    self.__data         = None
    self.__dataCopy     = None
    self.__sender       = None

  def start(self):
    """!\brief Start the polling thread.

    """
    self.__pollTask = threading.Thread(None, self.__poll, 'DataDistributorPoll')
    if self.__pollTask is not None:
      self.__pollTask.start()

  def stop(self):
    """!\brief Stop the polling thread.

    """
    self.returnNone()   # Force the base class receiver loop to break out
    self.__pollTaskQuit = True
    self.__pollTask.join()

  def __poll(self):
    """!\brief Internal routine to drain the data distributor client socket.

    """
    while not self.__pollTaskQuit:
      self.__data, self.__sender = DD.DataDistributorClient.receive(self)
      time.sleep(.001)  # Let another thread have some CPU time

  def receive(self):
    """!\brief Receive a sampled value of the data and sender information.

    \return A list of the sampled data and sender's identification string.
            If the data buffer has not been refreshed since the last call,
            return None, None.
    """
    # Avoid returning the same data more than once by keeping a reference to
    # the last-returned data.  When there is a new data buffer the references
    # won't match.
    if self.__data is not self.__dataCopy:
      self.__dataCopy = self.__data
      return self.__dataCopy, self.__sender
    else:
      return None, None

---