gOCS.py

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


__facility__ = "Online"
__abstract__ = "OCS node"
__author__   = "Amedeo Perazzo <perazzo@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2005/06/23 23:54:48 $").split(' ')[1]
__version__ = "$Revision: 2.29 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import logging
import time
import math
import struct
import gDb
import gAttr

import LATTE.client.gException as gException

class GOCS(gDb.Gdb):
  """\brief OCS node.

  Has OCS specific registers and methods.

  Valid Registers:
  - \c stats_failed_events
  - \c stats_failed_event_sends
  - \c stats_valid_events
  - \c stats_discarded_event_sends
  - \c stats_length_mismatch_count
  - \c stats_events_not_sent
  - \c stats_filter_pkt_errors
  - \c stats_filter_src_errors
  - \c stats_filter_passes
  - \c stats_filter_fails
  - \c stats_handled_events

  Event statistics:

  The following statistics registers are initialized
  at the start of each RunControl run:

  - \c stats_failed_events -- Counts events where
  the eventHandler receives a bad status for the event.

  - \c stats_failed_event_sends -- Counts events where
  the socket send failed with an error other than
  EWOULDBLOCK.

  - \c stats_valid_events -- Counts when a valid event
  has been successfully sent to the client.

  - \c stats_discarded_event_sends -- Counts cases when an
  event send failed due to the fact that the send
  returned an EWOULDBLOCK error.

  - \c stats_length_mismatch_count -- Counts cases when
  the length argument passed to the event handler did
  not match the length provided in the event header.

  - \c stats_events_not_sent -- Counts when an event is
  not sent over the socket due a filter or a scaler.

  - \c stats_filter_pkt_errors -- Counts when the filtered
  event has a packet error in its contribution.

  - \c stats_filter_src_errors -- Counts when the filtered
  event has a source error in its contribution.

  - \c stats_filter_passes -- Counts when the event goes through the filter.

  - \c stats_filter_fails -- Counts when the event fails the filter.

  - \c stats_handled_events -- Counts when the event is received by the SBC event handler.

  """
  ProtocolVersion  = 2
  ProtocolRevision = 1

  __attrs = [
    # Registers; IDs kept for backward compatibility with GLAT
    gAttr.GattrReg('stats_failed_events',          8, 4),
    gAttr.GattrReg('stats_failed_event_sends',     9, 4),
    gAttr.GattrReg('stats_valid_events',          10, 4),
    gAttr.GattrReg('stats_discarded_event_sends', 11, 4),
    gAttr.GattrReg('stats_length_mismatch_count', 12, 4),
    gAttr.GattrReg('stats_events_not_sent',       13, 4),
    gAttr.GattrReg('stats_filter_pkt_errors',     14, 4),
    gAttr.GattrReg('stats_filter_src_errors',     15, 4),
    gAttr.GattrReg('stats_filter_passes',         16, 4),
    gAttr.GattrReg('stats_filter_fails',          17, 4),
    gAttr.GattrReg('stats_handled_events',        18, 4),
    ]

  def __init__(self, client):
    self.__cbDict = {}  # dictionary of callback parameters
    gDb.Gdb.__init__(self, client, None, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('ggLATread', reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('ggLATload', reg, value)

  def evtHandlerSendAll(self):
    """\brief Sets the current event mode to send all events to the client.
    """
    name = 'evtHandlerSendAll'
    self.__cbDict.clear()
    self.__cbDict['name'] = name
    response = self.cmdrsp(name)
    return response.status()

  def evtHandlerSendNothing(self):
    """\brief Sets the current event mode to send no data events to the client.
    """
    name = 'evtHandlerSendNothing'
    self.__cbDict.clear()
    self.__cbDict['name'] = name
    response = self.cmdrsp(name)
    return response.status()

  def evtHandlerSendErrorsOnly(self):
    """\brief Sets the current event mode to send only error events to the client.
    """
    name = 'evtHandlerSendErrorsOnly'
    self.__cbDict.clear()
    self.__cbDict['name'] = name
    response = self.cmdrsp(name)
    return response.status()

  def evtHandlerSendAcdScalers(self, marker, prescale=0):
    """\brief Sets the current event mode to send only events containing the
    ACD software scalers to the client upon recept of the given marker.  All
    marker zero events are accumulated by the scaler code.  If an event is
    triggered with the specified marker, the scaler data will be delivered with
    that event.  Thus, if the specified marker is zero, then all data events
    will be accompanied by the scaler data.  In addition, marker zero events can
    be prescaled before delivery to the client.  A \a prescale value of zero
    (the default) delivers every marker zero event.  A \a prescale value of
    0xffffffffL disables prescaling and delivers no events.

    \param marker   - Marker to value to use
    \param prescale - Prescale value to use
    """
    name = 'evtHandlerSendAcdScalers'
    self.__cbDict.clear()
    self.__cbDict['name'] = name
    self.__cbDict['marker'] = marker
    self.__cbDict['prescale'] = prescale
    response = self.cmdrsp(name, marker, prescale)
    return response.status()

  def evtHandlerSendPrescaled(self, prescale):
    """\brief Sets the current event mode to send prescaled events to the client.
    A \a prescale value of zero delivers every event.  A \a prescale value of
    0xffffffffL disables prescaling and delivers no events.

    \param prescale - Prescale value to use
    """
    name = 'evtHandlerSendPrescaled'
    self.__cbDict.clear()
    self.__cbDict['name'] = name
    self.__cbDict['prescale'] = prescale
    response = self.cmdrsp(name, prescale)
    return response.status()

  def evtHandlerPrescaleExternal(self, prescale):
    """\brief Sets the current event mode to prescale externally triggered events.
    Only events with only the external trigger firing will be prescaled.
    A \a prescale value of zero delivers every event.  A \a prescale value of
    0xffffffffL disables prescaling and delivers no events.
    \param prescale - Prescale value to use
    """
    name = 'evtHandlerPrescaleExternal'
    self.__cbDict.clear()
    self.__cbDict['name'] = name
    self.__cbDict['prescale'] = prescale
    response = self.cmdrsp(name, prescale)
    return response.status()

  def evtHandlerFilterTkrHits(self, lowThreshold = 0, towerMask = 0xffff, highThreshold = 0xffffffffL, prescale = 0xffffffffL):
    """\brief Sets the current event mode to the Tracker Hit Filter

    The Tracker Hit Filter filters events based on the number of hits in the
    tracker.  Only events with no errors will be filtered.

    The filter algorithm sums up the number of hits found in the tracker
    contributions of the towers given in the \a towerMask and requires this
    total number of hits to be greater than or equal to the \a lowThreshold
    value and less than or equal to the \a highThreshold value in order to
    send the event downstream.  The default threshold values allow all events
    to pass the filter, i.e., the default low threshold is zero, and the default
    high threshold is larger than the full LAT can generate.

    The \a towerMask value is constructed by setting the bit at the position
    corresponding to the tower address of the tower to be included.  Bit zero
    is the least significant, right-most bit and corresponds to the tower with
    LATp address zero.  By default, all 16 towers are included in the filter
    calculation.

    A \a prescale can be applied to allow a fraction of the events that don't
    pass the TKR hit filter through.  If the \a prescale value is zero, the TKR
    hit filter is ignored.  If the \a prescale value is 0xffffffffL (the
    default), prescaling is disabled and filtering is determined by the TKR hit
    filter.  If prescaling is enabled, every event is considered for prescaling,
    not just the events that fail the TKR hit filter.

    \param lowThreshold  - Minimum number of TKR hits needed to pass the event downstream
    \param towerMask     - Mask of the towers participating in the filter
    \param highThreshold - Maximum number of TKR hits allowed to pass the event downstream
    \param prescale      - Prescale value to use
    """
    name = 'evtHandlerFilterTkrHits'
    self.__cbDict.clear()
    self.__cbDict['name'] = name
    self.__cbDict['lowThreshold'] = lowThreshold
    self.__cbDict['towerMask'] = towerMask
    self.__cbDict['highThreshold'] = highThreshold
    self.__cbDict['prescale'] = prescale
    response = self.cmdrsp(name, lowThreshold, towerMask, highThreshold, prescale)
    return response.status()

  def evtHandlerSetVerbosity(self, verbosity):
    """\brief Sets the event server verbosity.

    \param verbosity - Verbosity value to use
    """
    response = self.cmdrsp('evtHandlerSetVerbosity', verbosity)
    return response.status()

  def evtClearEvtSeqMSW(self):
    """\brief Clears the event sequence counter.

    """
    response = self.cmdrsp('evtClearEvtSeqMSW')
    return response.status()

  def synchronize(self):
    """\brief Synchronize the SBC's clock with the host's clock.
    """
    (fraction, integer) = math.modf(time.time())
    seconds = int(integer)
    nanoseconds = int(fraction*1000000000)
    return self.cmdrsp('ocsSetTime', seconds, nanoseconds)

  def getCallbackParams(self):
    """\brief Return a dictionary of the parameters used in the active OES callback
    """
    return self.__cbDict

  def getVersion(self):
    """\brief Get the protocol versions of code running on the SBC.
    """
    response = self.cmdrsp('ocsVersion', '!H', '!H')
    return (response.payloads()[0], response.payloads()[1])

  def getStartupScriptInfo(self):
    """\brief Retrieve CVS $Id: gOCS.py,v 2.29 2005/06/23 23:54:48 perazzo Exp $ info for the startup script.

    \return A list of CVS related info in the form: [filename, version, date, time, user]
    """
    format = '!128s'
    size = struct.calcsize(format)
    strng = self.cmdrsp('ocsstrncpy', format, "startupScriptInfo", size).payloads()
    value = ''.join(strng).rstrip('\x00')
    sValue = value.split(" ")
    if len(sValue) != 8:
      logging.error("*** Unable to retrieve startup script info")
      return None
    else:
      return [sValue[1].split(',')[0]] + sValue[2:6]

  def verifyVersion(self):
    """\brief Verify that the protocol version of the code running on the SBC
    is one the host code is expected to support.
    """
    (version, revision) = self.getVersion()
    if version != GOCS.ProtocolVersion or revision < GOCS.ProtocolRevision:
      logging.error("gOCS: server protocol version is %d.%d expected %d.%d"
                    %(version, revision,
                      GOCS.ProtocolVersion, GOCS.ProtocolRevision))
      status = gException.LATInterfaceStatus.status('OCS_BDVER')
      raise gException.LATInterfaceException(status)

  def cmxAsBuilt(self):
    asbuilt = {}
    format = '!32s'
    idptr = self.cmdrsp('CMX_asBuiltScan', 0).status()
    while idptr:
      version = self.__getVersion(idptr)
      time    = self.__getTime(idptr)
      name    = self.__getString(idptr, 'CMX_asBuiltGetConstit', format)
      package = self.__getString(idptr, 'CMX_asBuiltGetPackage', format)
      user    = self.__getString(idptr, 'CMX_asBuiltGetUser', format)
      idptr   = self.cmdrsp('CMX_asBuiltScan', idptr).status()
      asbuilt[name] = [package, version, user, time]
    return asbuilt

  def __getString(self, constituent, function, format):
    size = struct.calcsize(format)
    ptr = self.cmdrsp(function, constituent).status()
    string = self.cmdrsp('strncpy', format, ptr, size).payloads()
    return ''.join(string).rstrip('\x00')

  def __getVersion(self, constituent):
    response = self.cmdrsp('CMX_asBuiltGetVersion',
                           constituent,'!c','!H','!H','!H')
    ver = str(response.payloads()[0])
    if ver == 'U':
      return '<unknown>'
    elif ver == 'T':
      return '<test>'
    elif ver == 'D':
      return '<dev>'
    else:
      maj = str(response.payloads()[1])
      min = str(response.payloads()[2])
      rev = str(response.payloads()[3])
      return ''.join(['V',maj,'-',min,'-',rev])

  def __getTime(self, constituent):
    GLATEPOCH = 0x3a4fc880
    buildtime = self.cmdrsp('CMX_asBuiltGetTime', constituent).status()
    return time.strftime('%Y-%02m-%02d %H:%02M:%02S',
                         time.gmtime(buildtime+GLATEPOCH))

---