rcTransitions.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 finite state transistions classes"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/07/19 20:06:56 $").split(' ')[1]
__version__  = "$Revision: 2.137 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from   threading import Thread, Event, Lock
import logging   as     log
import os
import time
import sys
import types
import struct

import rcReportGen
import rcRunIdHelper
import rcHouseKeeping
import rcFitsWriter
import rcArchiver
import LATsweep
import rcComplStatus
import rcTestReport
import rcUtil
from   RunControlCommon import RunControlCommon


from   LATTE.tools              import FreeSpace
from   LATTE.tools              import DataExport
from   LATTE.trigger            import rcDefaultTrigger
from   LATTE.client             import gLog, gException
from   LATTE.database           import gGLT
from   LATTE.client.gEvtCli     import EvtCli
from   LATTE.database.gVersions import Gversions, ROOT_DIR_ENVS

class rcTransitions(object):
  "Class that handles the state machine transitions issued by Run Control"
  __SWEEP_MARKER     = 5               # Arbitrary marker value for recognizing
                                       #   when the event pipeline is flushed

  COMPL_STATUS_UNDEFINED            = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('UNDEFINED')
  COMPL_STATUS_ABORTED              = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('ABORTED')
  COMPL_STATUS_ERROR                = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('FAILED')
  COMPL_STATUS_SUCCESS              = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('PASSED')
  COMPL_STATUS_FAILED               = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('FAILED')
  COMPL_STATUS_PASSED               = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('PASSED')
  COMPL_STATUS_PASSED_CONDITIONALLY = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('PASSED CONDITIONALLY')
  COMPL_STATUS_MARGINAL             = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('MARGINAL')
  COMPL_STATUS_OPERATOR_ABORTED = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('OPERATOR ABORTED')
  COMPL_STATUS_INCOMPLETE = \
      rcComplStatus.rcCompletionStatus.getCompletionStatus('INCOMPLETE')

  # Database node for storing session variables
  #__dbn      = GDBN()

  # Watermark for diskspace warning
  DISKSPACE_WARN_LEVEL = (200*1024*1024)

  # Deadtime related constants
  DEADTIME_RATE_IN_MHZ = 20.0
  TIMEBASE_RATE_IN_MHZ = 16.6666667

  EVENT_HANDLER_STANDARD      = 0
  EVENT_HANDLER_LEAN_AND_MEAN = 1
  EVENT_HANDLER_PLAYBACK      = 2
  EVENT_HANDLER_CUSTOM        = 3


  def __init__(self, rc, userId, debug):
    fn = "rcTransitions.__init__"
    log.debug("%s -- %s" % (fn, self.getName()))
    self.__userId      = userId

    # Used in case the script is run in standalone mode
    if debug.__class__.__name__ == 'RunControlCommon':
      self.__common      = debug
      self.__debug       = None
    else:
      self.__debug       = debug
      if rc is not None:
        self.__common    = rc.common()
      else:
        raise RuntimeError, "Please supply a RunControlCommon object"

    # The following data members are meant to be marked "protected"
    self.rc                    = rc
    self.gui                   = rc # For backward compatibility

    self.__complStatus         = rcComplStatus.rcCompletionStatus()

    self.prefs                 = self.__common.prefMan().preferences()
    if self.__common.getLAT() is None:
      if rc is not None:
        rc.execGUImethod(rc.loadSchema)
      else:
        msg = "Please select a schema first"
        log.error(msg)
        raise RuntimeError, msg
    self.lat                   = self.__common.getLAT()
    self.xbrd                  = self.__common.getXBRD()
    self.ocs                   = self.__common.getOCS()
    self.evtCli                = self.__common.getEvtCli()
    self.__cmdCli              = self.__common.getCmdCli()

    self.__trigger             = None
    self.__archiver            = None
    self.__archiverClass       = None
    self.__fits                = None
    self.__errArchiver         = None
    self.__badArchiver         = None
    self.__eventHandlerReady   = Event()
    self.__sweepEvent          = Event()
    self.__sweepEvent.set()
    self.__evtHandlerQuit      = False

    self.evtCnt                = 0
    self.__SBCevtCnt           = 0
    self.__pauseCount          = 0
    self.__pausedTime          = 0
    self.__pauseTime           = None
    self.__startTime           = None
    self.__strobeTime          = None
    self.__elapsedTime         = 0
    self.__endTime             = None
    self.__excludedTime        = 0
    self.__excludeTime         = 0
    self.__excluding           = False
    self.__excludeLock         = Lock()
    self.__badEvents           = 0
    self.__errEvents           = 0
    self.__trgParErrorEvt      = 0
    self.__pktErrorEvt         = 0
    self.__hsk                 = None
    self.__tstamp              = None
    self.__tstampRaw           = None
    self.__deadtimeLock        = Lock()
    self.__deadtimeCtrReg      = {}
    self.__deadTimeVal         = {}
    self.__deadTimeTS          = {}
    self.__avgDeadTime         = {}
    self.__statMon             = None
    self.__dgSize              = 0
    self.__dgSumSize           = 0L
    self.__lastDgSumSize       = 0
    self.__instByteRate        = 0.0
    self.__lastEvtCnt          = 0
    self.__lastSBCevtCnt       = 0
    self.__lastTime            = 0
    self.__lastSBCtime         = 0
    self.__lastDgSumSize       = 0
    self.__instByteRate        = 0.0

    # This will contain the parent suite name during execution
    self.__suite               = None

    # This will contain the parent suite instance during execution
    self.__suiteInst           = None

    # This will be True if it is the last script in the suite
    self.__lastSuiteScript     = False

    self.__EBFplayback         = self.__common.options().playback is not None

    self.__runIdHelper         = rcRunIdHelper.rcRunIdHelper(self.prefs)
    self.runId                 = 'N/A'

    self.__customReportData    = {}

    if rc is not None:
      self.__paramVerifier       = self.rc.parameterVerifier()

    self.__verifyStatus        = None

    self.__appStatus           = None
    self.__completionStatus    = self.COMPL_STATUS_UNDEFINED

    self.__dds               = self.__common.getDDS()

    # Contains the full path for the run based message log
    self.__runMsgLogFile = None

    # Contains a dictionary of snapshot results
    self.__snapResult = {}

    if self.rc is not None and 'statusMonitor' in dir(rc):
      statMon = self.rc.statusMonitor()
      statMon.addWatchItem('Run Id', self.getRunId)
      statMon.addWatchItem('Test Name', self.getName)
      statMon.addWatchItem('Suite Name', self.getSuite)
      statMon.addWatchItem('Additional Input Files', self.getAddlInputFiles)
      statMon.addWatchItem('Completion Status', self.getCompletionStatusStr,
                            alarmExpr="@!='" + self.__complStatus.getCompletionStatusStr(rcTransitions.COMPL_STATUS_PASSED)+"'")
      statMon.addWatchItem('Event Count', self.getEventCount)
      statMon.addWatchItem('TEM Error Events', self.getErrorEvents, alarmExpr='!=0')
      statMon.addWatchItem('Trg Parity Error Events', self.getTrgParityErrorEvents, alarmExpr='!=0')
      statMon.addWatchItem('Packet Error Events', self.getPacketErrorEvents, alarmExpr='!=0')
      statMon.addWatchItem('Bad SBC Events', self.getBadEvents, alarmExpr='!=0')
      statMon.addWatchItem('Start Time', self.getStartTime)
      statMon.addWatchItem('End Time', self.getEndTime)
      statMon.addWatchItem('Elapsed Time', self.getElapsedTime)
      statMon.addWatchItem('Average SBC Event Rate', self.getSBCEventRate)
      statMon.addWatchItem('Instant SBC Event Rate', self.getInstSBCEventRate)
      statMon.addWatchItem('Average Event Rate', self.getEventRate)
      statMon.addWatchItem('Instant Event Rate', self.getInstEventRate)
      statMon.addWatchItem('Average Datagram Size', self.getAvgDatagramSize)
      statMon.addWatchItem('Instant Datagram Size', self.getInstDatagramSize)
      #statMon.addWatchItem('Average Byte Rate', self.getAvgByteRate)
      statMon.addWatchItem('Instant Byte Rate', self.getInstByteRate)
      statMon.addWatchItem('Avg DeadTime', self.getAvgDeadTime, offBoard=True)
      statMon.addWatchItem('GEM DeadTime (Avg , Inst)', self.getGemDeadTime, offBoard=True)
      statMon.addWatchItem('Pause Count', self.getPauseCount)
      statMon.addWatchItem('Paused Time', self.getPausedTime)
      statMon.addWatchItem('Run Message Log File', self.getRunMsgLogFile)
      statMon.addWatchItem('Archive File', self.getArchiveFile)
      #statMon.addWatchItem('FITS File', self.getFITSfile)
      #statMon.addWatchItem('HSK File', self.getHSKfile)
      #statMon.addWatchItem('Bad SBC Events File', self.getBadEventsFile)
      #statMon.addWatchItem('TEM Error Events File', self.getErrorEventsFile)
      statMon.addWatchItem('SBC Handled Events', self.getSBCHandledEvents, offBoard=True)
      statMon.addWatchItem('Valid Events', self.getValidEvents, offBoard=True)
      statMon.addWatchItem('Failed Event TCP Sends', self.getFailedEventSends, alarmExpr='!=0', offBoard=True)
      statMon.addWatchItem('Failed Event H/W Xmits', self.getFailedEvents, alarmExpr='!=0', offBoard=True)
      statMon.addWatchItem('Discarded Events', self.getDiscardedEvents, alarmExpr='!=0', offBoard=True)
      statMon.addWatchItem('Length Mismatched Events', self.getLengthMismatchedEvents, alarmExpr='!=0', offBoard=True)
      statMon.addWatchItem('Unsent Events', self.getUnsentEvents, alarmExpr='!=0', offBoard=True)
      statMon.addWatchItem('Error Log Count', self.__common.getErrorLogCount, alarmExpr='!=0')
      statMon.addWatchItem('Free Disk Space', FreeSpace.FreeSpace,
                           alarmExpr='<'+ str(rcTransitions.DISKSPACE_WARN_LEVEL))
      self.__statMon = statMon

    self.__reportGen = rcReportGen.rcReportGen(os.path.join(self.prefs["reportdir"], 'rcReport.out'), self.prefs)

    try:
      self.setArchiverClass(rcArchiver.rcArchiver)
    except (ImportError, IOError), e:
      log.error("%s: Archiver disabled: %s" % (fn, e))

    if self.__common.options().noerrfile is not None:
      self.handleEventOutput = self.__handleEventOutputStub
    else:
      self.handleEventOutput = self.__handleEventOutput

  def getFailedEvents(self):
    """\brief Return failed event count.

    OES increments this counter when
    there is a packet transmission error.

    \return Failed event count.
    """
    if self.__cmdCli.isConnected():
      try:
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        cnt = self.ocs.stats_failed_events
        self.__cmdCli.setDebug(saveDebug)
        return cnt
      except: pass
    return 0

  def getFailedEventSends(self):
    """\brief Return number of failed event sends.

    OES increments this counter when there is a TCP
    transport problem between the SBC and the teststand.

    \return Number of failed event sends.
    """
    if self.__cmdCli.isConnected():
      try:
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        cnt = self.ocs.stats_failed_event_sends
        self.__cmdCli.setDebug(saveDebug)
        return cnt
      except: pass
    return 0

  def getSBCHandledEvents(self):
    """\brief Return number of events handled by the SBC.

    OES increments this counter when an event has been
    received by the event handler.

    \return Number of events handled by the SBC.
    """
    if self.__cmdCli.isConnected():
      try:
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        self.__SBCevtCnt = self.ocs.stats_handled_events
        self.__cmdCli.setDebug(saveDebug)
        return self.__SBCevtCnt
      except: pass
    return 0

  def getValidEvents(self):
    """\brief Return number of events successfully sent.

    OES increments this counter when an event has been
    successfully transmitted to the teststand.

    \return Number of valid events sent.
    """
    if self.__cmdCli.isConnected():
      try:
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        cnt = self.ocs.stats_valid_events
        self.__cmdCli.setDebug(saveDebug)
        return cnt
      except: pass
    return 0

  def getDiscardedEvents(self):
    """\brief Return number of events discarded.

    OES increments this counter when an event has been
    discarded. Currently this method always returns 0.

    \return Number of events discarded.
    """
    if self.__cmdCli.isConnected():
      try:
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        cnt = self.ocs.stats_discarded_event_sends
        self.__cmdCli.setDebug(saveDebug)
        return cnt
      except: pass
    return 0

  def getLengthMismatchedEvents(self):
    """\brief Return number of length mismatched events.

    OES increments this counter when an event size doesn't
    match the length specified in the event.
    Currently this method always returns 0.

    \return Number of length mismatched events.
    """
    if self.__cmdCli.isConnected():
      try:
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        cnt = self.ocs.stats_length_mismatch_count
        self.__cmdCli.setDebug(saveDebug)
        return cnt
      except: pass
    return 0

  def getUnsentEvents(self):
    """\brief Return number of events filtered or prescaled.

    OES increments this counter when there is a filter
    or prescale set that prevents the event from being
    transmitted.

    \return Number of unsent events.
    """
    if self.__cmdCli.isConnected():
      try:
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        cnt = self.ocs.stats_events_not_sent
        self.__cmdCli.setDebug(saveDebug)
        return cnt
      except: pass
    return 0

  def getAvgDeadTime(self, temId=None):
    """\brief Return the average deadtime.

    Returns the average deadtime as a percentage for a TEM specified by \a temId
    or all TEMs in the schema as a dictionary.

    \return Average deadtime(s)
    """
    if self.__cmdCli.isConnected():
      self.__deadtimeLock.acquire()
      avgDeadTimes = self.__calcDeadTime(temId)
      self.__deadtimeLock.release()
      if temId is not None:
        if avgDeadTimes[temId] is not None:
          self.__avgDeadTime[temId] = "%3.3f" % avgDeadTimes[temId]
        else:
          self.__avgDeadTime[temId] = "N/A"
        return self.__avgDeadTime[temId]
      else:
        for (id, dt) in avgDeadTimes.items():
          if dt is not None:
            self.__avgDeadTime[id] = "%3.3f" % dt
          else:
            self.__avgDeadTime[id] = "N/A"
    return self.__avgDeadTime

  def getGemDeadTime(self):
    """\brief Return the Average GEM dead time as a percentage
    """
    if self.__cmdCli.isConnected():
      if not self.lat.existsGEM():
        return ("N/A", "N/A")
      saveDebug = self.__cmdCli.getDebug()
      self.__deadtimeLock.acquire()
      if 'GEM' not in self.__deadTimeVal.keys() or \
         'GEM' not in self.__deadTimeTS.keys()  or \
          self.__startTime is None:
        self.__deadtimeLock.release()
        return ("N/A", "N/A")
      gst = self.lat.GEM.GEMST
      self.__cmdCli.setDebug(0)
      try:
        val, ts = gst.extCtrRead(gst.regs['livetime'].id()).payloads()
      except gException.LATInterfaceException, e:
        if e.errstr()[0] == 'OCS_TMO':
          self.__deadtimeLock.release()
          return ("TO", "TO")
        else:
          raise

      # need to remove excluded time from both numerator and denominator
      excludeTime = (time.time() - self.__startTime - self.__getElapsedTime()) * rcTransitions.DEADTIME_RATE_IN_MHZ * 1000000
      dTime = val - self.__deadTimeVal['GEM'] - excludeTime
      iDTime = val - self.__deadTimeVal['LASTGEM']
      dTS   = (ts - self.__deadTimeTS['GEM']) - excludeTime
      iDTS  = (ts - self.__deadTimeTS['LASTGEM'])
      self.__deadtimeLock.release()
      self.__cmdCli.setDebug(saveDebug)

      if dTS != 0:
        avgLiveTime =  (float(dTime)/float(dTS)) * 100.0
      else:
        avgLiveTime = None
        return ("N/A", "N/A")

      if iDTS != 0:
        instLiveTime = (float(iDTime)/float(iDTS)) * 100.0
      else:
        instLiveTime = 0.0

      self.__deadTimeVal['LASTGEM'] = val
      self.__deadTimeTS['LASTGEM'] = ts

      return ("%3.3f" % (100.0 - avgLiveTime), "%3.3f" % (100.0 - instLiveTime))


  def getRunId(self):
    """\brief Return the run id

    \return Run id
    """
    return self.runId

  def getSchemaConfigFile(self):
    """\brief Return the full path of the schema file

    \return Schema file path
    """
    return self.getSessionVar('_LATSchemaFile')

  def getAddlInputFiles(self):
    """\brief Return a list containing the additional input files.

    This list is automatically generated from the XML files included
    in the schema using the <include> tag. The list contains only the
    filename portion and doesn't include the full path.

    \return List of additional input files.
    """
    if self.lat is not None:
      return [f for (p,f) in map(os.path.split, self.lat._GLAT__includeFiles)]

  def getRunMsgLogFile(self):
    """\brief Return the filename for the message log for the current run.

    \return Message log filename.
    """
    if self.__runMsgLogFile is not None:
      return os.path.basename(self.__runMsgLogFile)
    else:
      return None

  def getArchiveFile(self):
    """\brief Return the filename for the archive file (LDF file).

    \return Archive filename.
    """
    if self.__archiver is not None:
      return self.__archiver.getFileName()
    else:
      return None

  def getBadEventsFile(self):
    """\brief Return the filename for the bad events archive.

    \return Bad events archive filename.
    """
    if self.__badArchiver is not None:
      return self.__badArchiver.getFileName()
    else:
      return None

  def getErrorEventsFile(self):
    """\brief Return the filename for the error events archive.

    \return Error events archive filename.
    """
    if self.__errArchiver is not None:
      return self.__errArchiver.getFileName()
    else:
      return None

  def getFITSfile(self):
    """\brief Return the filename for the FITS file.

    \return FITS filename.
    """
    if self.__fits is not None:
      return self.__fits.getFileName()
    else:
      return None

  def getHSKfile(self):
    """\brief Return the filename for the housekeeping FITS file.

    \return Housekeeping FITS filename.
    """
    if self.__hsk is not None:
      return self.__hsk.getFileName()
    else:
      return None


  def getPauseCount(self):
    """\brief Return number of times the test is paused.

    \return Pause count
    """
    return self.__pauseCount

  def getPausedTime(self):
    """\brief Return the amount of time spent in pause.

    \return Pause time.
    """
    if self.__pauseTime is not None:
      return "%.2f seconds" % (self.__pausedTime + (time.time() - self.__pauseTime))
    else:
      return "%.2f seconds" % self.__pausedTime

  def getEventCount(self):
    """\brief Return number of events received.

    \return Event count
    """
    return self.evtCnt

  def getElapsedTime(self):
    """\brief Return the elapsed time spent during test execution.

    \return Elapsed time.
    """
    return "%.2f seconds"  % self.__getElapsedTime()

  def __getElapsedTime(self):
    self.__excludeLock.acquire()
    if self.__strobeTime is not None and \
       self.__pauseTime  is     None and not self.__excluding:
      elapsedTime = self.__elapsedTime + (time.time() - self.__strobeTime)
    else:
      elapsedTime = self.__elapsedTime
    self.__excludeLock.release()
    return elapsedTime


  def getEventRate(self):
    """\brief Return the event rate.

    \return Event rate.
    """
    self.__excludeLock.acquire()
    if self.__strobeTime is not None and \
       self.__pauseTime  is     None and not self.__excluding:
      elapsedTime = self.__elapsedTime + (time.time() - self.__strobeTime)
      if elapsedTime > 0:
        msg = "%.2f events/sec" % (self.evtCnt / elapsedTime)
      else:
        msg = "N/A"
    elif self.__elapsedTime == 0:
      msg = "N/A"
    else:
      msg = "%.2f events/sec" % (self.evtCnt / (self.__elapsedTime))
    self.__excludeLock.release()
    return msg

  def getSBCEventRate(self):
    """\brief Return the SBC event handling rate.

    \return SBC event handling rate.
    """
    self.__excludeLock.acquire()
    if self.__strobeTime is not None and \
       self.__pauseTime  is     None and not self.__excluding:
      elapsedTime = self.__elapsedTime + (time.time() - self.__strobeTime)
      if elapsedTime > 0:
        msg = "%.2f events/sec" % (self.__SBCevtCnt / elapsedTime)
      else:
        msg = "N/A"
    elif self.__elapsedTime == 0:
      msg = "N/A"
    else:
      msg = "%.2f events/sec" % (self.__SBCevtCnt / (self.__elapsedTime))
    self.__excludeLock.release()
    return msg

  def getInstEventRate(self):
    """\brief Return the instant event rate.

    \return Instant event rate.
    """
    self.__excludeLock.acquire()
    evtCnt               = self.evtCnt
    dC                   = evtCnt - self.__lastEvtCnt
    self.__lastEvtCnt    = evtCnt

    dgSumSize            = self.__dgSumSize
    dS                   = dgSumSize - self.__lastDgSumSize
    self.__lastDgSumSize = dgSumSize

    now                  = time.time()
    dT                   = now - self.__lastTime
    self.__lastTime      = now

    if dT == 0:  dT = .00001
    msg = "%.2f events/sec" % (float(dC) / dT)
    self.__instByteRate = float(dS) / dT
    self.__excludeLock.release()
    return msg

  def getInstSBCEventRate(self):
    """\brief Return the instant SBC event handling rate.

    \return Instant SBC event handling rate.
    """
    self.__excludeLock.acquire()
    evtCnt               = self.__SBCevtCnt
    dC                   = evtCnt - self.__lastSBCevtCnt
    self.__lastSBCevtCnt    = evtCnt

    now                  = time.time()
    dT                   = now - self.__lastSBCtime
    self.__lastSBCtime   = now

    if dT == 0:  dT = .00001
    msg = "%.2f events/sec" % (float(dC) / dT)
    self.__excludeLock.release()
    return msg

  def getInstDatagramSize(self):
    """\brief Return the instant datagram size.

    \return Instant datagram size.
    """
    self.__excludeLock.acquire()
    msg = str(self.__dgSize)
    self.__excludeLock.release()
    return msg

  def getAvgDatagramSize(self):
    """\brief Return the instant datagram size divided by the number of events.

    \return Average datagram size
    """
    self.__excludeLock.acquire()
    if self.evtCnt:
      msg = str(float(self.__dgSumSize) / float(self.evtCnt))
    else:
      msg = "N/A"
    self.__excludeLock.release()
    return msg

  def getInstByteRate(self):
    """\brief Return the instant datagram byte rate

    \return Average datagram byte rate
    """
    return "%.2f Kbytes/sec" % (self.__instByteRate / 1024)

  def getStartTime(self):
    """\brief Return the test start time

    \return Test start time in GMT as a tuple
    """
    if self.__startTime is not None:
      return time.asctime(time.gmtime(self.__startTime))
    else:
      return None

  def getEndTime(self):
    """\brief Return the test end time

    \return Test end time in GMT as a tuple
    """
    if self.__endTime is not None:
      return time.asctime(time.gmtime(self.__endTime))
    else:
      return None

  def getBadEvents(self):
    """\brief Return number of events with a bad GGLT status

    \return Number of bad events
    """
    return self.__badEvents

  def getErrorEvents(self):
    """\brief Return number of error events

    \return Number of error events
    """
    return self.__errEvents

  def getTrgParityErrorEvents(self):
    """\brief Return number of trigger parity error events

    \return Number of trigger parity error events
    """
    return self.__trgParErrorEvt

  def getPacketErrorEvents(self):
    """\brief Return number of packet error events

    \return Number of packet error events
    """
    return self.__pktErrorEvt


  def setCmdCli(self, cmdCli):
    """\brief Set the command client instance (used in suites)

    \param A CmdCli instance
    """
    self.cmdCli = cmdCli

  def setEvtCli(self, evtCli):
    """\brief Set the event client instance.

    Used to set the custom event client.

    \param A CmdCli instance
    """
    log.debug("Event client set to: %s" % evtCli.__class__.__name__)
    evtCli.setSocket(self.evtCli.socket())
    self.evtCli = evtCli

  def getEvtCli(self):
    """\brief Return the current event client instance.

    \return An EvtCli instance
    """
    return self.evtCli

  def getDataDistributor(self):
    """\brief Return the data distribution server instance.

    \return Data distribution server instance.
    """
    return self.__dds

  def setSessionVar(self, key, value):
    """\brief Set session variable \a key to value \a value.

    Session variables are data that is shared between different runs.
    They exist as long as the run control session they are defined in.
    Typical uses of session variables are to pass data from one suite
    script to another or to maintain state during a multiple step
    test run.

    \param key   Session variable identifier.
    \param value Session variable value.
    """
    sessionVars = self.__common.getDBN()
    if sessionVars is not None:
      sessionVars[key] = value
    else:
      raise RuntimeError, "Database node does not exist"

  def getSessionVar(self, key):
    """\brief Return the session variable identified by \a key.

    \param key Session variable identifier.

    \return Value of the session variable if it exists,
            otherwise None.
    """
    sessionVars = self.__common.getDBN()
    if sessionVars is not None and sessionVars.has_key(key):
      return sessionVars[key]
    else:
      return None

  def setPrefs(self, prefs):
    """\brief Explicitly set preferences.

    When scripts are run in standalone mode it may be
    necessary to pass in a script defined set of preferences.

    The preferences specified in \a prefs get appended to
    the set of preferences read from the configuration file.

    \param prefs Preferences as a dictionary.
    """
    for (key, val) in prefs.items():
      self.prefs[key] = val

  def setCompletionStatus(self, completionStatus, completionStatusStr=None):
    """\brief Sets the completion status of the test.

    Please use one of the following:

      - COMPL_STATUS_ABORTED              = -2
      - COMPL_STATUS_ERROR                = -3
      - COMPL_STATUS_FAILED               = -3
      - COMPL_STATUS_SUCCESS              =  0
      - COMPL_STATUS_PASSED               =  0
      - COMPL_STATUS_PASSED_CONDITIONALLY = -4
      - COMPL_STATUS_MARGINAL             = -5

    Or a user defined completion status in which case
    a description needs to be supplied along with the code.

    \param completionStatus    Numeric completion status code
    \param completionStatusStr Completion status description

    """
    if not self.__complStatus.isCompletionStatus(completionStatus):
      if completionStatusStr is None:
        raise RuntimeError, "Need to specify a completion status description " \
                            "when specifying a user defined completion status"
      else:
        addRes = self.__complStatus.addCompletionStatus(completionStatus, completionStatusStr)
        if addRes == -2:
          raise RuntimeError, "Completion status description '%s' already exists " \
                              "under a different status code." % completionStatusStr
    self.__completionStatus = completionStatus

  def getCompletionStatus(self):
    """\brief Return the completion status code.

    Returns the code set by the script or
    COMPL_STATUS_UNDEFINED if it hasn't been set.

    \return Completion status code.
    """
    if self.__appStatus is None:
      return self.__completionStatus
    else:
      return self.__appStatus

  def getCompletionStatusStr(self):
    """\brief Return the description of the completion status.

    Returns the code as set by the script or
    'UNDEFINED' if it hasn't been set.

    \return Completion status description.
    """
    completionStatus = self.getCompletionStatus()
    return self.__complStatus.getCompletionStatusStr(completionStatus)
    #if completionStatus == rcTransitions.COMPL_STATUS_ABORTED:
    #  return("ABORTED")
    #elif completionStatus == rcTransitions.COMPL_STATUS_ERROR:
    #  return("ERROR")
    #elif completionStatus == rcTransitions.COMPL_STATUS_SUCCESS:
    #  return("SUCCESS")
    #else:
    #  return("UNDEFINED")

  def getSnapshotStatus(self, snapId=None):
    """\brief Return snapshot result(s).

    Returns a dictionary of snapshot results or if snapId is specified,
    returns the corresponding snapshot status.

    \param snapId Optional snapshot id.

    \return Snapshot status as a boolean or status dictionary.
            None, if a snapshot with an id of \a snapId doesn't exist.
    """
    if snapId is None:
      return self.__snapResult
    elif snapId in self.__snapResult:
      return self.__snapResult[snapId]
    else:
      return None

  def __isTestComplete(self):
    if self.__common.options().securedir is not None:
      requiredOptions = ['snapnbl', 'datasave']
      complete = True
      for option in requiredOptions:
        if self.prefs[option] != 1:
          complete = False
          break
      return complete
    else:
      return True

  def getHSK(self):
    """
    \brief Return the housekeeping class instance.

    \return Housekeeping class instance
    """
    return self.__hsk

  def addCustomReportData(self, key, value):
    """\brief Add custom report data to the run report.

    This method allows the application to add any additional data
    that Run Control is not already providing to the run report
    (rcReport.out).

    When the custom report data gets processed and written to the
    database, it will go under the "AdditionFields" column. Please
    only provide values that can be converted to a string.

    \param key   Custom report data identifier.
    \param value Custom report data value.
    """
    self.__customReportData[key] = value

  def getParameterVerifier(self):
    """\brief Return the parameter verifier instance

    \return Parameter verifier instance
    """
    return self.__paramVerifier

  def addExportedFile(self,file=None,delete=False):
    """\brief Add file to the list of files to be exported.

    \param file   file to be added
    \param delete delete original on export (default False)
    """
    if file is not None:
      (filePath,fileName) = os.path.split(file)
      self.__exportedFiles.append( [filePath,fileName,delete] )

      # Try to extract the report file from the rcTestReport instance
      # that the script may have been using.
      if self.__testReport is None:
        for objStr in dir(self):
          obj = getattr(self, objStr)
          if '__class__' in dir(obj):
            if rcTestReport.rcTestReport in obj.__class__.__mro__:
              self.__testReport = obj
              break
      if self.__testReport is not None and file in self.__testReport.getReports():
        self.__testReportFile = fileName


  def getFileTimeStamp(self):
    """\brief Return the formatted timestamp used to name output files.

    Using this method, applications can request the formatted timestamp
    value used in naming archive, snapshot and housekeeping files.
    The format is YYMMDDHHMISS.

    \return Formatted GMT timestamp
    """
    return self.__tstamp

  def getRawTimeStamp(self):
    """\brief Return the raw timestamp as returned from gmtime().

    \return Raw GMT timestamp tuple.
    """
    return self.__tstampRaw

  def getSuite(self):
    """\brief Return the name of the suite that this script is a part of.

    \return Suite name.
    """
    return self.__suite

  def setSuite(self, suite):
    """\brief Set name of the suite for this script.

    Called from rcSuite.

    \param suite Name of the suite
    """
    self.__suite = suite

  def getSuiteInstance(self):
    """\brief Return the suite instance that this script is a part of.

    \return Suite instance.
    """
    return self.__suiteInst

  def setSuiteInstance(self, suiteInst):
    """\brief Set the suite instance for this script.

    Called from rcSuite.

    \param suiteInst Suite instance.
    """
    self.__suiteInst = suiteInst

  def setLastSuiteScript(self):
    """\brief Set the script as the last one in the suite.

    Called from rcSuite.
    """
    self.__lastSuiteScript = True

  def isLastSuiteScript(self):
    """\brief Check if the script is the last one.

    """
    return self.__lastSuiteScript

  def getState(self):
    """\brief Return the state of the running script.

    If the script is running as part of a suite then the script
    state is simulated.

    \return Script state
    """
    if self.isRunFromSuite():
      return self.getSuiteInstance().getAppState()
    elif self.rc is not None:
      return self.rc.getFSM().current_state


  def trigger(self, trg=None, replaceShut=True):
    """\brief Return the trigger used in this script or
    initialize the trigger.

    \param trg         Trigger object.
    \param replaceShut Flag to specify whether the trigger's default
                       shut logic should be wrapped by Run Control's
                       LATsweep shut logic. Default is True.

    \return Trigger object.
    """
    if trg is not None:
      self.__trigger = trg
      if replaceShut:
        # Don't cache the shut call more than once.  Otherwise you get recursion.
        if "_shut" not in dir(self.__trigger):
          self.__trigger._shut = self.__trigger.shut
        latSweep = LATsweep.LATsweep(self.lat, self.__trigger, self.__trigger._shut)
        self.__trigger.shut = latSweep.shut
    return self.__trigger

  def isRunFromSuite(self):
    """\brief Check if the script is being run from a suite.

    \return True  If the script is being run from a suite,
            False otherwise.
    """
    return self.__suite is not None

  def __genReport(self):
    log.debug("Generating run report...")
    self.__reportGen.initialize(self.__tstampRaw)
    self.__reportGen.addField("TestName", self.getName())
    if self.__suite is not None:
      self.__reportGen.addField("SuiteName", self.__suite)
    self.__reportGen.addField("RunId", self.runId)
    if self.prefs.has_key("operator"):
      self.__reportGen.addField("Operator", self.prefs["operator"])
    if self.prefs.has_key("userid"):
      self.__reportGen.addField("OperatorId", self.prefs["userid"], rcReportGen.UNITS_LONG)
    self.__reportGen.addField("EventCount", str(self.evtCnt), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("BadEventCount", str(self.__badEvents), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("ErrorEventCount", str(self.__errEvents), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("TriggerParityErrorEventCount", str(self.__trgParErrorEvt), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("PacketErrorEventCount", str(self.__pktErrorEvt), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("PauseCount", str(self.__pauseCount), rcReportGen.UNITS_INT)
    self.__reportGen.addField("PausedTime", str(self.__pausedTime), rcReportGen.UNITS_FLOAT)
    self.__reportGen.addField("StartTime", str(time.gmtime(self.__startTime)))
    self.__reportGen.addField("ElapsedTime", str(self.__elapsedTime), rcReportGen.UNITS_FLOAT)
    self.__reportGen.addField("EndTime", str(time.gmtime(self.__endTime)))
    self.__reportGen.addField("SBCHandledEvents", str(self.getSBCHandledEvents()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("ValidEvents", str(self.getValidEvents()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("FailedEventTCPSends", str(self.getFailedEventSends()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("FailedEventHWXmits", str(self.getFailedEvents()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("DiscardedEvents", str(self.getDiscardedEvents()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("LengthMismatchedEvents", str(self.getLengthMismatchedEvents()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("UnsentEvents", str(self.getUnsentEvents()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("FreeDiskSpace", str(FreeSpace.FreeSpace()), rcReportGen.UNITS_LONG)
    self.__reportGen.addField("SchemaConfigFile", os.path.split(self.__common.getDBN()['_LATSchemaFile'])[1])
    self.__reportGen.addField("AdditionalInputFiles", str(self.getAddlInputFiles()))
    self.__reportGen.addField("AssociatedFiles", str([exp[1] for exp in self.__exportedFiles]))
    self.__reportGen.addField("CallbackParameters", str(self.__common.getOCS().getCallbackParams()))

    releases = {}
    failed = []
    failedNoVersion = []

    if int(self.prefs["versionnbl"]) == 1:
      try:
        self.__waitCursor()
        versions = Gversions.getModuleVersions(self.ocs)
        for (hwComp, hwVer) in self.__common.getHardwareVersions().items():
          if hwComp in versions:
            log.warning("Hardware component %s with version %s conflicts with a module of same name" %
                        (hwComp, hwVer)
                      )
          else:
            versions[hwComp] = hwVer

        for (module, version) in versions.items():
          if version.strip() == '':
            failedNoVersion.append(module)
            failed.append(module)
        self.__normalCursor()
      except:
        log.exception("Error in retrieving version information. Setting VersionData to an empty list.")
        versions = {}
      self.__reportGen.addField("VersionData", str(versions))

    if int(self.prefs["disableverification"]) == 0:
      try:
        filesToVerify= [self.__common.getDBN()['_LATSchemaFile']] + self.lat._GLAT__includeFiles
        if os.environ.has_key("VXW_ROOT"):
          filesToVerify.append(os.path.join(os.environ["VXW_ROOT"], "*.vx"))
          filesToVerify.append(os.path.join(os.environ["VXW_ROOT"], "lib/mv2304/*.o"))
        for env in ROOT_DIR_ENVS:
          if os.environ.has_key(env):
            release = Gversions.verifyModuleDigests(digestDataFile=None, rootDirEnv=env,
                                                    additionalFilesToVerify=filesToVerify)
            subsys = env[:env.find("_ROOT")]
            releases[subsys] = release[0]
            for module in release[1]:
              if module not in failed:
                failed.append(module)
            noVersionInRelease = False
            for module in failedNoVersion:
              if module in release[1]:
                noVersionInRelease = True
                break
            if len(release[1]) > 0 or noVersionInRelease:
              log.error("Some modules failed verification for %s release %s. Check Elogbook for the modules that failed." % (subsys, release[0]))
      except:
        log.exception("Error in verification. Setting Release and ModulesFailedVerification to empty lists.")
        releases = {}
        failed = []
    self.__reportGen.addField("Release", str(releases))
    self.__reportGen.addField("ModulesFailedVerification", str(failed))

    if self.__fits is not None:
      self.__reportGen.addField("FITSfile", self.__fits.getFileName())
    if self.__archiver is not None and self.__archiver.getFileName() is not None:
      self.__reportGen.addField("ArchiveFile", self.__archiver.getFileName())
    if self.__errArchiver is not None and self.__errArchiver.getFileName() is not None:
      self.__reportGen.addField("ErrorArchive", self.__errArchiver.getFileName())
    if self.__badArchiver is not None and self.__badArchiver.getFileName() is not None:
      self.__reportGen.addField("BadEventArchive", self.__badArchiver.getFileName())
    # Change as per LTE-193
    #hskOutputEnabled = (int(self.prefs["envmonnbl"]) == 1)
    hskOutputEnabled = False
    # Change as per LTE-193
    #hskReadOnly = (int(self.prefs["envmonreadonly"]) == 1)
    hskReadOnly = False
    if hskOutputEnabled and self.__hsk is not None and not hskReadOnly:
      self.__reportGen.addField("HSKArchive", self.__hsk.getFileName())
    if self.prefs.has_key("logfilename"):
      self.__reportGen.addField("LogFile", self.prefs["logfilename"])
    if self.getRunMsgLogFile() is not None:
      self.__reportGen.addField("RunLogFile", self.getRunMsgLogFile())
    comments = []
    if self.rc is not None:
      cw = self.rc.getCommentWidget()
      if cw is not None:
        hist = cw.getHistory()
        tstamp = cw.getTimestamps()
        comments += zip(tstamp, hist)
      cw = self.rc.getEndRunComments()
      if cw is not None:
        hist = cw.getHistory()
        tstamp = cw.getTimestamps()
        comments += zip(tstamp, hist)
    self.__reportGen.addField("Comments", str(comments))
    for (key, value) in self.__customReportData.items():
      self.__reportGen.addField(key, str(value))
    if self.prefs is not None:
      prefs = self.prefs
      if prefs.has_key("lastsite"):
        self.__reportGen.addField("Site",           prefs["lastsite"])
      if prefs.has_key("lastparticletype"):
        self.__reportGen.addField("ParticleType",   prefs["lastparticletype"])
      if prefs.has_key("lastinstrumenttype"):
        self.__reportGen.addField("InstrumentType", prefs["lastinstrumenttype"])
      if prefs.has_key("lastorientation"):
        self.__reportGen.addField("Orientation",    prefs["lastorientation"])
      if prefs.has_key("lastphase"):
        self.__reportGen.addField("Phase",          prefs["lastphase"])
    self.__reportGen.addField("AverageDeadTime", str(self.getAvgDeadTime()))
    self.__reportGen.addField("GEMDeadTime", str(self.getGemDeadTime()))
    if self.__verifyStatus is not None:
      self.__reportGen.addField("ParamVerify", str(self.__verifyStatus))
    allSerials = self.lat.getAllSerialNos()
    repSerials = {}
    if allSerials != {}:
      for (node, serialnos) in allSerials.items():
        strNode = "%s%s" % (node.getName(), node.getIdTuple())
        repSerials[strNode] = serialnos
      self.__reportGen.addField("SerialNos", str(repSerials))
    if self.__testReportFile is not None:
      self.__reportGen.addField("ScriptReport", self.__testReportFile)

    tc = self.trigger().conditions()
    tList = []
    if tc.roi():       tList.append("roi")
    if tc.calLow():    tList.append("calLow")
    if tc.calHigh():   tList.append("calHigh")
    if tc.tkr():       tList.append("tkr")
    if tc.periodic():  tList.append("periodic")
    if tc.solicited(): tList.append("solicited")
    if tc.cno():       tList.append("cno")
    if tc.external():  tList.append("external")
    self.__reportGen.addField("TriggerMask", str(tList))

    errorLogCount = self.__common.getErrorLogCount()
    self.__reportGen.addField("ErrorLogCount", str(errorLogCount), rcReportGen.UNITS_INT)
    # If there are any error logs during the run override the status as FAILED
    if self.getCompletionStatus() == self.COMPL_STATUS_PASSED and errorLogCount != 0:
      log.warn("Errors were encountered during the run. Overriding the completion status from %s to FAILED." % (self.getCompletionStatusStr()))
      self.__appStatus = self.COMPL_STATUS_FAILED
    # As per Eduardo's request override the PASSED completion status to be
    # INCOMPLETE if any of his criteria (see __isTestComplete) aren't met
    elif self.getCompletionStatus() == self.COMPL_STATUS_PASSED and \
           not self.__isTestComplete():
      log.warn("Test was not complete. Overriding the completion status as INCOMPLETE.")
      self.__appStatus = self.COMPL_STATUS_INCOMPLETE

    self.__reportGen.addField("CompletionStatus", str(self.getCompletionStatus()), rcReportGen.UNITS_INT)
    self.__reportGen.addField("CompletionStatusStr", self.getCompletionStatusStr())

    # We're done!
    self.__reportGen.writeReportXML()
    log.debug("Run report generation complete.")

  def takeSnapshot(self, stream=sys.stdout, fileName=None,
                   captureGTIC=1, captureGAEQ=1,
                   trigger=None,
                   configName='', configVersion=''):
    """\brief Take a snapshot of the hardware.

    If snapshots are enabled in Run Control preferences,
    two snapshots will be taken, one before and one after
    the test has been run. This method allows the application
    to take a snapshot at a specific point of the run.

    It is the application's responsibility to add the
    resulting file to the list of exported files by calling
    the addExportedFile method.

    Since snapshots essentially have the same format as
    configuration blocks, configName and configVersion parameters
    can be used to output a named configuration.

    \param stream         Output stream for the snapshot.
                          sys.stdout by default.
    \param fileName       Full path of the snapshot file.
    \param captureGTIC    Capture TEM environmental quantities.
                          Enabled by default.
    \param captureGAEQ    Capture AEM environmental quantities.
                          Enabled by default.
    \param trigger        Trigger object. If miniGLT is used as a
                          trigger then GLT registers can be snapshot.
    \param configName     Configuration name
    \param configVersion  Configuration version

    \return True  if the snapshot was successful,
            False if errors were encountered during snapshot
    """

    if self.__statMon is not None:
      self.rc.execGUImethod(self.__statMon.stopWatch)

    result = self.lat.takeSnapshot(stream, fileName,
                          captureGTIC, captureGAEQ,
                          trigger, configName, configVersion)

    if self.__statMon is not None:
      self.rc.execGUImethod(self.__statMon.startWatch)

    return result

  def readConfig(self, cfgFileName):
    """\brief Read a configuration XML file.

    \param cfgFileName Full path of the configuration file.

    \return Sequence number for this configuration. This number
            can later be passed to applyConfig.
    """
    seq = self.lat.readConfig(cfgFileName)
    if seq != -1 and cfgFileName not in self.lat._GLAT__includeFiles:
      self.lat._GLAT__includeFiles.append(cfgFileName)
    return seq

  def applyConfig(self, seq=None, gxbrd=None):
    """\brief Apply configuration.

    \param seq   Sequence number of the configuration.
                 If None, then apply all configurations.
    \param gxbrd Apply the GXBRD configuration as well.
                 Disabled by default.
    """
    # RESET state check is disabled until CAL scripts are fixed -ST
    ## Check if FSM is None in case we are in a suite
    #if self.isRunFromSuite():
    #  currentState = self.getSuiteInstance().getScriptState()
    #else:
    #  currentState = self.rc.getFSM().current_state
    #if currentState != 'RESET':
    #  msg = "Can not apply configuration when the run state is %s" % currentState
    #  log.error(msg)
    #  raise RuntimeError, msg
    #else:
    self.lat.applyConfig(seq, gxbrd)

  def setArchiverClass(self, archiverClass):
    """\brief Set a custom archiver class.

    Set a custom archiver class.  This is typically done in the __init__ method
    of the userApplication class.

    \param The archiver class (not the instance)

    """
    self.__archiverClass = archiverClass
    log.debug("Event archiver set to: %s", self.__archiverClass.__name__)

  def getArchiverInstance(self):
    """\brief Return the archiver instance.

    Returns the archiver instance.  Can be used by the user application.

    \return Archiver instance
    """
    return self.__archiver

  def startExcludeTime(self):
    """\brief Save the start time for exclusion from the run's elapsed time.

    This method allows excluding some amount of time from the run's elapsed
    time.  The start time is the time that the method is called.

    Note that time spent in the PAUSED state is also excluded from the elapsed
    time value.  Overlapping time is excluded from the elapsed time only once.
    """
    if not self.__excluding:
      self.__excludeLock.acquire()
      now = time.time()
      self.__excluding = True
      self.__excludeTime  = now
      self.__elapsedTime += now - self.__strobeTime
      self.__strobeTime   = now
      self.__excludeLock.release()
    elif self.__pauseTime is not None:
      pass                              # Going into PAUSED started it
    else:
      assert not self.__excluding, "Error: " + \
             "Attempt made to exclude time when it is already being excluded"

  def endExcludeTime(self):
    """\brief Strobe the end time for exclusion from the run's elapsed time.

    This method allows excluding some amount of time from the run's elapsed
    time.  The end time is the time that the method is called.  The difference
    between the end time and the start time is added to the excluded time.
    """

    if self.__pauseTime is None:
      assert self.__excluding, "Error: startExcludeTime was not called"
      self.__excludeLock.acquire()
      now = time.time()
      dExcludedTime         = now - self.__excludeTime
      self.__excludedTime += dExcludedTime
      self.__elapsedTime  += now - self.__strobeTime - dExcludedTime
      self.__strobeTime    = now
      self.__excludeTime   = None
      self.__excluding     = False
      self.__excludeLock.release()
    else:                               # In PAUSED state: nothing to do
      pass

  def adjustExcludeTime(self, dExcludeTime):
    """\brief This method allows adjustment of the amount of time to be
    excluded from the run's elapsed time.

    The amount of time to be excluded from the run's elapsed time can be
    adjusted positivily or negativily with this method.  It does not take
    into account any other effects on the excluded time, such as whether
    the run was in the PAUSED state.

    \param dExcludeTime  The amount of time to be excluded as given by the
    difference of two time.time() values.
    """
    # Ensure this doesn't interrupt another thread diddling excludeTime
    self.__excludeLock.acquire()
    self.__excludedTime += dExcludeTime
    self.__excludeLock.require()

  def rcSetup(self):
    """\brief Setup transition method.


    """
    fn = "rcTransitions.rcSetup"
    log.debug("%s -- %s" % (fn, self.getName()))

    # Set the Global Trigger
    if not self.lat.existsGEM():
      glt = self.xbrd.GLT
      if glt is None: # temporary: eventually will be explicit in schema
        glt = self.xbrd._GXBRD__addGLT()
      glt.initialize()
      self.setSessionVar('_glt', glt)

      # Disable triggers
      glt.disableMask()        # call this directly.  don't use trigger()

    # Apply the configuration to the hardware
    self.__waitCursor()
    self.applyConfig(gxbrd = self.xbrd)
    self.__normalCursor()

    # set the event mode to take events normally
    self.ocs.evtHandlerSendAll()
    self.ocs.synchronize()
    self.ocs.verifyVersion()

    # Disable all the saturation counters, disable the loop and set the delay to 2Hz
    for tem in self.lat.TEM.values():
      tic = tem.TIC
      tic.satCtrLoopDisable()
      tic.satCtrSetLoopDelay(30)
      for (regName, regAttr) in tic.regs.items():
        if regName.startswith('sat_'):
          tic.satCtrDisable(regAttr.id())

    self.__deadtimeLock.acquire()
    self.__deadtimeCtrReg.clear()
    self.__deadTimeVal.clear()
    self.__deadTimeTS.clear()
    self.__avgDeadTime.clear()
    self.__deadtimeLock.release()


    # The application may pick a different event handler in the SETUP and
    # START_RUN transitions.  If it doesn't make sure there is a default.
    self.selectEventHandler(rcTransitions.EVENT_HANDLER_STANDARD)

    # Change as per LTE-193
    #hskReadOnly = (self.rc is not None) and (int(self.prefs["envmonreadonly"]) == 1)
    hskReadOnly = False

    if hskReadOnly:
      self.__hsk = rcHouseKeeping.rcHouseKeeping(self.lat, None, rcHouseKeeping.MODE_READONLY)
    else:
      self.__hsk = rcHouseKeeping.rcHouseKeeping(self.lat, os.path.split(self.__common.getDBN()['_LATSchemaFile'])[1])

    # As per LTE-395, clear the custom rcReport.out dictionary before user setup
    self.__customReportData    = {}

    # Call the application back
    try:
      status = self.setup()
      if status is not None:  return status
    except:
      log.exception("Exception in " + self.getName() + ".setup()")
      self.__appStatus = self.COMPL_STATUS_FAILED
      return False                      # Stay in RESET state

    # finish setting up the trigger, add the GEM or GLT
    if self.lat.existsGEM():
      if self.trigger() is None:
        # there's no trigger defined, define a default
        # As there's no "real" trigger, don't replace the shut method
        self.trigger( rcDefaultTrigger.rcGEMDefaultTrigger(), replaceShut = False )
      self.trigger().GEM(self.lat.downGEM())
    else:
      if self.trigger() is None:
        # there's no trigger defined, define a default
        self.trigger( rcDefaultTrigger.rcMiniGLTDefaultTrigger(), replaceShut = False )
      self.trigger().GLT(glt)
    # commit the trigger.  This class defined in rcTrg{Gem,MiniGLT}.py
    self.trigger().commit()


  def rcTeardown(self):
    fn = "rcTransitions.rcTeardown"
    log.debug("%s -- %s" % (fn, self.getName()))

    # Just in case this was missed in __stopRun because of an exception...
    self.__strobeTime = None

    # Call the application back
    try:
      status = self.teardown()
    except:                             # Continue as if nothing had happened
      log.exception("Exception in " + self.getName() + ".teardown()")
      self.__appStatus = self.COMPL_STATUS_FAILED
      status = None                     # Go into RESET state

    # reset things defined in rcSetup
    self.trigger(None, replaceShut=False)

    return status

  def rcStartRun(self):
    fn = "rcTransitions.rcStartRun"
    log.debug("%s -- %s" % (fn, self.getName()))

    self.evtCnt             = 0
    self.__SBCevtCnt        = 0
    self.__lastEvtCnt       = 0
    self.__lastSBCevtCnt    = 0
    self.__dgSize           = 0
    self.__dgSumSize        = 0L
    self.__appStatus        = None
    self.__completionStatus = self.COMPL_STATUS_UNDEFINED
    self.__badEvents        = 0
    self.__errEvents        = 0
    self.__trgParErrorEvt   = 0
    self.__pktErrorEvt      = 0
    self.__endTime          = None
    self.__startTime        = None
    self.__excludeLock.acquire()
    self.__elapsedTime      = 0
    self.__strobeTime       = None
    self.__excluding        = False
    self.__excludedTime     = 0
    self.__excludeLock.release()
    self.__pauseCount       = 0
    self.__pausedTime       = 0
    self.__snapResult       = {}

    # Initialize the event statistics
    self.ocs.stats_failed_events         = 0
    self.ocs.stats_failed_event_sends    = 0
    self.ocs.stats_valid_events          = 0
    self.ocs.stats_handled_events        = 0
    self.ocs.stats_discarded_event_sends = 0
    self.ocs.stats_length_mismatch_count = 0
    self.ocs.stats_events_not_sent       = 0
    self.ocs.stats_filter_pkt_errors     = 0
    self.ocs.stats_filter_src_errors     = 0
    self.ocs.stats_filter_passes         = 0
    self.ocs.stats_filter_fails          = 0

    self.__common.resetErrorLogCount()

    self.__clearEventSizeNTuple()

    # This while loop makes sure the session log level filename is different
    # than the run level filename by waiting 1 second if necessary.
    # This condition may happen in standalone scripts and suites.
    while True:
      # The timestamp is measured here because things below depend on its value.
      # Therefore the run time includes the amount of time spent in the parameter verifier
      # in addition to the time the user spends entering the parameters.
      self.__tstampRaw   = time.gmtime()
      self.__tstamp      = time.strftime('%y%m%d%H%M%S', self.__tstampRaw)
      if self.prefs.has_key("logfilename"):
        logfilename = self.prefs["logfilename"]
        if self.__tstamp != logfilename[3:15]:
          break
      else:
        break
      time.sleep(1)

    self.__exportedFiles      = []

    # Contains the rcTestReport instance used by the script if any
    self.__testReport = None
    # Contains the file name for the test report generated by the script
    self.__testReportFile = None

    self.runId = self.__runIdHelper.nextRunId()

    # Check exported directory, as per LTE-226
    if int(self.prefs["dataexport"]) == 1:
      exportDir = os.path.abspath(self.prefs["exportdir"])
      if not os.path.exists(exportDir):
        msg = "Export directory %s does not exist.  Aborting run" % exportDir
        log.fatal(msg)
        return False    # reject the transition

    # Change as per LTE-193
    #hskOutputEnabled = (self.rc is not None) and (int(self.prefs["envmonnbl"]) == 1)
    hskOutputEnabled = False
    if hskOutputEnabled:
      hskFileName = rcHouseKeeping.getFileNameFromTS(self.__tstamp)
      self.__hsk.initialize(filePath=self.prefs["logdir"],
                            fileName=hskFileName,
                            compress=(int(self.prefs["envmoncompress"]) == 1))
      self.__hsk.start()

    # Load the archive file writer, if desired
    if self.prefs is not None:
      archiveOutputEnabled = (int(self.prefs["datasave"]) == 1)
      if archiveOutputEnabled:
        archFileName = self.__archiverClass.getFileNameFromTS(self.__tstamp)
        self.__archiver = self.__archiverClass(filePath=self.prefs["datadir"],
                                                fileName=archFileName)
        self.__archive = self.__archiveIt
      else:
        self.__archive = self.__archiveDummy

    if self.__dds is not None:
      self.__publish = self.__publishIt
    else:
      self.__publish = self.__publishDummy

    if self.rc is not None:
      self.__paramVerifier.initialize(self.getName())
    self.__verifyStatus = None

    # publish the startRun on dds
    self.publishConsumerDG('startRun='+self.getRunId())

    # Set the deadtime LRS Counter Mask here to 'total'
    # if not specified in a configuration.
    for (gtemId, gtem) in self.lat.TEM.items():
      if self.lat.getSysReg(gtem.TIC, 'busy_lrs_mask') is None:
        lrsMask = gtem.TIC.busy_lrs_mask
        oldLrsMask = lrsMask
        if lrsMask & 0x7 != 0x3:
          lrsMask |= 0x7
          lrsMask &= ~0x4
          log.debug("%s: [OVR] TEM[%d].TIC.BUSY_LRS_MASK=0x%08x (0x%08x)" % (fn, gtemId, lrsMask, oldLrsMask))
          gtem.TIC.busy_lrs_mask = lrsMask

    # Call the application back
    try:
      status = self.startRun()
    except:
      log.exception("Exception in " + self.getName() + ".startRun()")
      self.__appStatus = self.COMPL_STATUS_FAILED
      status = False                    # Stay in STOPPED state
    if status is not None:
      # startRun rejected, cleanup here.
      if hskOutputEnabled:
        self.__hsk.stop()
      return status

    if self.__common.options().securedir is not None or self.__common.options().paramverify is not None:
      # Don't prompt the parameter verifier if the script
      # is in a suite that is called from another suite or
      # if it is not the first script in the suite
      scriptSeq = 0
      if self.isRunFromSuite():
        suiteInst = self.getSuiteInstance()
        if suiteInst.getSuite() is None:
          scriptSeq = suiteInst.getScriptSequence()
        else:
          scriptSeq = -1
      if scriptSeq == 0 or scriptSeq == 1:
        self.__paramVerifier.add("Schema File", os.path.split(self.__common.getDBN()['_LATSchemaFile'])[1])
        self.__paramVerifier.add("Particle Type", self.prefs["lastparticletype"])
        self.__paramVerifier.add("Orientation", self.prefs["lastorientation"])
        self.__paramVerifier.add("Site", self.prefs["lastsite"])
        self.__paramVerifier.add("Instrument Type", self.prefs["lastinstrumenttype"])
        self.__paramVerifier.add("Phase", self.prefs["lastphase"])
      self.__verifyStatus = self.rc.execGUImethod(self.__paramVerifier.verify)
      if self.__verifyStatus == 1: # The user successfully signed off on the parameters
        pass
      elif self.__verifyStatus == 0: # The user cancelled the verification
        log.error("Parameter verification failed because the user cancelled verification.")
        return self.__verifyStatus
      else:
        if self.__verifyStatus is None: self.__verifyStatus = -1
        log.error("Parameter verification failed due to an unknown reason.")
        return self.__verifyStatus

    self.__runMsgLogFile = None
    if int(self.prefs["lognbl"]) == 1:
      self.__runMsgLogFile = os.path.join(self.prefs["logdir"],
                                          "msg" + self.__tstamp + ".log")
      self.__runMsgLog = self.__common.startRunLog(self.__runMsgLogFile)
    log.info("""%s -- Test %s starting run, Operator: %s,"""
             """ Run Id: %s, Time Started: %s -- %s"""
              % (fn, self.getName(), self.prefs["operator"],
                 self.runId, self.__tstamp, time.asctime(self.__tstampRaw)))

    # Take snapshot. Note that the triggers must be disabled prior to
    # this action, therefore the glt changes are being committed afterwards.

    snapshotEnabled = 0
    if self.prefs.has_key("snapnbl"):
      snapshotEnabled = (int(self.prefs["snapnbl"]) == 1)
    if snapshotEnabled:
      self.__waitCursor()

      snFile = os.path.join(self.prefs["snapshotdir"],
                            "rsa" + self.__tstamp + ".xml")
      self.__snapResult["rsa"] = self.takeSnapshot(stream=None, fileName=snFile,
                            captureGTIC=1, captureGAEQ=1, trigger=self.trigger())
      self.addExportedFile(snFile,delete=True)

      self.__normalCursor()

    self.handleEventOutput()

    # Clear the event sequence
    self.ocs.evtClearEvtSeqMSW()
    if self.lat.existsGEM():
      self.lat.GEM.GEMC.sequence = 0
    else:
      self.trigger().GLT().TAG = 0
      self.trigger().GLT().EVENT_NUMBER = 0

    # Set up the LCB to deliver events
    self.lat.LCB.setEvtEnable(True)

    # Purge all event data remaining in socket
    purgeSize = self.evtCli.purge()
    if purgeSize != 0:
      log.warn("Socket purge encountered %d bytes of stale data" % purgeSize)

    # Check if the data directories exist and that there's enough space on the disks
    if self.rc is not None:
      fitsDir = self.prefs["fitsdir"]
      archDir = self.prefs["datadir"]
      warning = True
      for directory in (fitsDir, archDir):
        if not os.path.exists(directory):
          warning = self.rc.execGUImethod(self.rc.warnDirectoryExist, directory)
        elif (FreeSpace.FreeSpace(directory) < rcTransitions.DISKSPACE_WARN_LEVEL):
          warning = self.rc.execGUImethod(self.rc.warnFreeSpace,
                                          rcTransitions.DISKSPACE_WARN_LEVEL)
        if warning:            # OK, continue
          pass
        else:
          return False         # reject the transition

      # Spawn a thread to handle events
      if self.trigger().sweepOnShut():
        self.__eventHandlerReady.clear()               # Clear handler ready state
        self.rc.eventHandler.spawn(self.__jacket, self.__eventHandlerFn)
        self.__eventHandlerReady.wait()                # Make sure handler ready
        # Sweep out stale events.  Status is returned, False = sweep timeout.
        swept = self.__sweep()
        if not swept:          # sweep event has timed out.
          log.critical("Sweep event timed out, aborting run and returning to RESET state")
          # As per LTE-363 make sure we create a run report and export the run
          self.__initStartRun(time.time())
          self.__appStatus = self.COMPL_STATUS_ABORTED
          self.__stopRun(fn)
          self.rc.doReset()
          return False         # reject the transition, sweep timeouts are bad

      if 'commandSynch' in dir(self):
        self.rc.commandSynch.spawn(self.__jacket, self.commandSynch)
    else:
      if self.trigger().sweepOnShut():
        self.__eventHandlerReady.clear()               # Clear handler ready state
        evtHandler = Thread(None, self.__eventHandlerFn, 'EventHandler', ())
        evtHandler.start()
        self.__eventHandlerReady.wait()                # Make sure handler ready
        # Sweep out stale events.  Status is returned, False = sweep timeout.
        swept = self.__sweep()
        if not swept:          # sweep event has timed out.
          log.critical("Sweep event timed out, aborting run and returning to RESET state")
          # As per LTE-363 make sure we create a run report and export the run
          self.__initStartRun(time.time())
          self.__appStatus = self.COMPL_STATUS_ABORTED
          self.__stopRun(fn)
          self.rc.doReset()
          return False         # reject the transition, sweep timeouts are bad

      if 'commandSynch' in dir(self):
        cmdSynch = Thread(None, self.commandSynch, 'CmdSynch', ())
        cmdSynch.start()

    # Handle enabling of the triggers
    enableTrigger = True                     # Default is to enable triggers
    if 'triggerEnableOverride' in dir(self): # Allow application to override
      enableTrigger = type(self.triggerEnableOverride) == types.MethodType and \
                      not self.triggerEnableOverride()
    now = time.time()

    if enableTrigger:
      # Write the user script's trigger mask settings to the hardware
      self.trigger().enable()

    self.__initStartRun(now)

    return status


  def __initStartRun(self, now):
    #Initialize timers
    self.__endTime     = None
    self.__startTime   = now
    self.__excludeLock.acquire()
    self.__elapsedTime = 0
    self.__strobeTime  = now
    self.__excludeLock.release()

    # Set baselines for dead time
    self.__deadtimeLock.acquire()
    for temId in self.lat.TEM.keys():
      tic = self.lat.TEM[temId].TIC
      if tic is not None:
        self.__deadtimeCtrReg[temId] = tic.regs['sat_deadtime_lrs_ctr']
        regNo = self.__deadtimeCtrReg[temId].id()
        resp = tic.read(regNo)
        self.__deadTimeVal[temId] = resp.value()
        self.__deadTimeTS[temId] = resp.payloads()[1]
      else:
        self.__deadTimeVal[temId] = 0
        self.__deadTimeTS[temId] = 0
    if self.lat.existsGEM():   # __deadTimeVal/TS are dicts, so Jim can add GEM to 'em.  :-)
      gst = self.lat.GEM.GEMST
      value, ts = gst.extCtrRead(gst.regs['livetime'].id()).payloads()
      self.__deadTimeVal['GEM'] = value
      self.__deadTimeTS['GEM']  = ts
      self.__deadTimeVal['LASTGEM'] = value
      self.__deadTimeTS['LASTGEM']  = ts
    else:
      self.__deadTimeVal['GEM'] = 0
      self.__deadTimeTS['GEM']  = 0
      self.__deadTimeVal['LASTGEM'] = 0
      self.__deadTimeTS['LASTGEM']  = 0
    self.__deadtimeLock.release()


  def __jacket(self, function, *args, **kwargs):
    """Jacketting method for catching exceptions and initiating graceful
    termination of the user application.
    """
    try:
      function(*args, **kwargs)
    except Exception, e:
      import logging
      logging.exception("%s: %s" % (function.__name__, e))
      self.__appStatus = self.COMPL_STATUS_ABORTED
      self.rc.doReset()

  def __handleEventOutput(self):
    # Load the FITS file writer, if desired
    fn = "__handleEventOutput"
    self.__fits = None
    if self.prefs is not None:
      fitsOutputEnabled = ("fitsnbl" in self.prefs) and (int(self.prefs["fitsnbl"]) == 1)
      if fitsOutputEnabled:
        try:
          fitsFileName = rcFitsWriter.getFileNameFromTS(self.__tstamp)
          self.__fits = rcFitsWriter.rcFitsWriter(filePath=self.prefs["fitsdir"],
                                                  fileName=fitsFileName,
                                                  format=rcFitsWriter.FORMAT_BYTE,
                                                  compress=(int(self.prefs["fitscompress"]) == 1),
                                                  flushInterval=100,
                                                  reportGen=self.__reportGen)
        except (ImportError, IOError), e:
          log.error("%s: FITS writer disabled: %s" % (fn, e))
      try:
        fileName = rcArchiver.rcArchiver.getFileNameFromTS(self.__tstamp)
        errFileName = 'err' + fileName.split('.',1)[0] + '.ldf'
        self.__errArchiver = rcArchiver.rcArchiver(filePath=self.prefs["datadir"],
                                                    fileName=errFileName)
        badFileName = 'bad' + fileName.split('.',1)[0] + '.ldf'
        self.__badArchiver = rcArchiver.rcArchiver(filePath=self.prefs["datadir"],
                                                    fileName=badFileName)
      except (ImportError, IOError), e:
        log.error("%s: Archiver disabled: %s" % (fn, e))

  def __handleEventOutputStub(self):
    pass

  def rcStopRun(self):
    fn = "rcTransitions.rcStopRun"
    log.debug("%s -- %s" % (fn, self.getName()))

    # Disable triggers
    self.trigger().disable()

    # Flush out the remaining triggers in the pipeline and exit evtHandler
    swept = self.__flushEvents()
    if not swept:             # sweep event has timed out.
      self.evtCli.abort()     # As sweep has timed out, evtHandler hasn't exited.
                              # force the exit with abort()

    self.__common.getDBN()['_event_size'] = 0

    # Call the application back after events are no longer flowing
    try:
      self.stopRun()       # RiC: It appears rejecting the transition won't work
    except:                             # Go into STOPPED state
      log.exception("Exception in " + self.getName() + ".stopRun()")
      self.__appStatus = self.COMPL_STATUS_FAILED

    # Stop the run - Must be done after the application stopRun()
    self.__stopRun(fn)

  def rcStop(self):
    fn = "rcTransitions.rcStop"
    log.debug("%s -- %s" % (fn, self.getName()))

    # Disable triggers
    self.trigger().disable()

    # Flush out the remaining triggers in the pipeline and exit evtHandler
    swept = self.__flushEvents()
    if not swept:             # sweep event has timed out.
      self.evtCli.abort()     # As sweep has timed out, evtHandler hasn't exited.
                              # force the exit with abort()

    self.__common.getDBN()['_event_size'] = 0

    # Mark the resume time
    now = time.time()
    self.__pausedTime += (now - self.__pauseTime)
    self.__pauseTime   = None

    if not self.__excluding:
      self.__excludeLock.acquire()
      dExcludedTime        = now - self.__excludeTime
      self.__excludedTime += dExcludedTime
      self.__elapsedTime  += now - self.__strobeTime - dExcludedTime
      self.__strobeTime    = now
      self.__excludeTime   = None
      self.__excludeLock.release()
    else:                 # Time is still being excluded: nothing to do
      pass

    # Call the application back after events are no longer flowing
    try:
      self.stop()         # RiC: It appears rejecting the transition won't work
    except:                             # Go into STOPPED state
      log.exception("Exception in " + self.getName() + ".stop()")
      self.__appStatus = self.COMPL_STATUS_FAILED

    # Stop the run
    self.__stopRun(fn)

  def rcPause(self):
    fn = "rcTransitions.rcPause"
    log.debug("%s -- %s" % (fn, self.getName()))

    # Sweep out any currently buffered triggers
    if self.trigger().sweepOnShut():
      swept = self.__sweep()
      if not swept:
        log.critical("Sweep event timed out, aborting run and returning to RESET state")
        self.rc.doReset()
        return False         # reject the transition, sweep timeouts are bad

    # Increment pause count
    self.__pauseCount += 1

    # Calculate elapsed time so far
    now = time.time()
    self.__pauseTime = now

    if not self.__excluding:
      self.__excludeLock.acquire()
      self.__excludeTime  = now
      self.__elapsedTime += now - self.__strobeTime
      self.__strobeTime   = now
      self.__excludeLock.release()
    else:                 # Time is already being excluded: nothing to do
      pass

    # Call the application back
    try:
      status = self.pause()
    except:                             # Go into PAUSED state
      log.exception("Exception in " + self.getName() + ".pause()")
      self.__appStatus = self.COMPL_STATUS_FAILED

    # Do a pseudo-resume if the PAUSE transition is rejected
    if status is not None:
      # Mark the resume time before reenabling triggers
      now = time.time()
      self.__pausedTime += (now - self.__pauseTime)
      self.__pauseTime   = None

      if not self.__excluding:
        self.__excludeLock.acquire()
        dExcludedTime        = now - self.__excludeTime
        self.__excludedTime += dExcludedTime
        self.__elapsedTime  += now - self.__strobeTime - dExcludedTime
        self.__strobeTime    = now
        self.__excludeTime   = None
        self.__excludeLock.release()
      else:                 # Time is still being excluded: nothing to do
        pass

      # Reenable triggers
      self.trigger().enable()

    return status

  def rcResume(self):
    fn = "rcTransitions.rcResume"
    log.debug("%s -- %s" % (fn, self.getName()))

    # Mark the resume time before reenabling triggers
    now = time.time()

    # Call the application back
    try:
      self.trigger().enable()
      status = self.resume()
    except:                             # Go into RUNNING state
      self.trigger().disable()
      log.exception("Exception in " + self.getName() + ".resume()")
      self.__appStatus = self.COMPL_STATUS_FAILED

    # Don't change the situation if the application rejected the transition
    if status is None:
      self.__pausedTime += (now - self.__pauseTime)
      self.__pauseTime   = None

      if not self.__excluding:
        self.__excludeLock.acquire()
        dExcludedTime        = now - self.__excludeTime
        self.__excludedTime += dExcludedTime
        self.__elapsedTime  += now - self.__strobeTime - dExcludedTime
        self.__strobeTime    = now
        self.__excludeTime   = None
        self.__excludeLock.release()
      else:                 # Time is still being excluded: nothing to do
        pass

      # Reenable triggers
      self.trigger().enable()

    return status

  # Not used anymore - ST
  #def extend(self):
  #  """Overload this function to provide additional space after the event in
  #  the datagram.  This space can be used to add application dependent
  #  LATcontributions to the datagram.  This method is evaluated at startRun time
  #  and not on a per trigger basis.  It should return a Python string big enough
  #  to fit whatever additional space is needed for the user data.  To gain
  #  access to this space use the LATdatagram.alloc(size) method.
  #  """
  #  return ""

# The following methods are meant to be overridden by the application

  def getName(self):
    return self.__class__.__name__

  def setup(self):
    "Method that is called on the SETUP transition"
    log.debug("rcTransitions.setup()")
    # The transition can be rejected by not returning None
    return None

  def teardown(self):
    "Method that is called on the TEARDOWN transition"
    log.debug("rcTransitions.teardown()")
    # The transition can be rejected by not returning None
    return None

  def startRun(self):
    "Method that is called on the START_RUN transition"
    log.debug("rcTransitions.startRun()")
    # The transition can be rejected by not returning None
    return None

  def stopRun(self):
    "Method that is called on the STOP_RUN transition"
    log.debug("rcTransitions.stopRun()")
    # The transition can be rejected by not returning None
    return None

  def pause(self):
    "Method that is called on the PAUSE transition"
    log.debug("rcTransitions.pause()")
    # The transition can be rejected by not returning None
    return None

  def resume(self):
    "Method that is called on the RESUME transition"
    log.debug("rcTransitions.resume()")
    # The transition can be rejected by not returning None
    return None

  def stop(self):
    "Method that is called on the STOP transition"
    log.debug("rcTransitions.stop()")
    # The transition can be rejected by not returning None
    return None

  def process(self, eventBuffer):
    "Method that is called on every data event taken"
    log.debug("rcTransitions.process()")


# Private methods appear below

## private:

  def __clearEventSizeNTuple(self):
    # Clear the event size plot ntuple
    dbn = self.__common.getDBN()
    if '_EventSizeNTuple' in dbn:
      dbn['_EventSizeNTuple'].clear()

  def __normalCursor(self):
    if self.rc is not None and 'normalCursor' in dir(self.rc):
      self.rc.normalCursor()

  def __waitCursor(self):
    if self.rc is not None and 'waitCursor' in dir(self.rc):
      self.rc.waitCursor()

  def __eventProgress(self):
    """
    Method used by the sweep logic to time out waiting for sweep events.
    This function returns the number of events that were handled by the
    event handler since the last time it was called.
    """
    progress = self.evtCnt - self.__lastEvtCnt
    self.__lastEvtCnt = self.evtCnt
    self.__lastSBCevtCnt = self.__SBCevtCnt
    return progress

  def __sweep(self):
    """
    Method used to ensure that the event pipeline is swept of pending events.
    When this method returns triggers are disabled but set up as they were upon
    entry.
    """

    # Wait for marked event to show up while pipelined events drain
    self.__waitCursor()
    # Make sure TEM registers are in a 'good' state for event data taking
    # and solicit the sweep trigger.
    swept = self.trigger().shut(self.__sweepEvent, self.__eventProgress)
    self.__normalCursor()
    # Triggers are disabled at this point.

    return swept

  def __flushEvents(self):
    # Cause eventHandler to exit when the sweep marker is seen

    # Handle the race condition when event handler
    # may exit before the sweep event is received.
    self.__sweepEvent.clear()
    self.__evtHandlerQuit = True

    swept = True
    # Sweep any buffered triggers
    if self.trigger().sweepOnShut():
      swept = self.__sweep()

    # Handle the race condition when event handler
    # may exit before the sweep event is received.
    self.__sweepEvent.set()
    return swept


  def __stopRun(self, fn='__stopRun'):
    # Calculate the final elapsed time
    now = time.time()
    self.__endTime      = now
    self.__excludeLock.acquire()
    if self.__strobeTime is not None:
      self.__elapsedTime += now - self.__strobeTime
    self.__strobeTime   = None
    self.__excludeLock.release()

    self.__avgDeadTime = self.__calcDeadTime()

    # Change as per LTE-193
    #hskOutputEnabled = (self.rc is not None) and (int(self.prefs["envmonnbl"]) == 1)
    hskOutputEnabled = False
    if hskOutputEnabled:
      self.__hsk.stop()

    # publish the endRun on dds
    self.publishConsumerDG('endRun='+self.getRunId())

    if self.__completionStatus == self.COMPL_STATUS_UNDEFINED:
      log.warn("Script completed with an undefined completion status. "
               "Please use the setCompletionStatus method.")

    # Close fits file
    if self.__fits is not None:
      self.__fits.close(self.rc.inShutdown)
    if self.__badArchiver is not None:
      self.__badArchiver.close()
      self.__removeZeroLengthFile(self.__badArchiver.getFilePath(), self.__badArchiver.getFileName())
      # need to check if file was removed before adding to export list..
      _fnameTmp = os.path.join(self.__badArchiver.getFilePath(), self.__badArchiver.getFileName())
      if os.path.exists(_fnameTmp):
        self.addExportedFile(_fnameTmp, delete=True)
      self.__badArchiver = None
    if self.__errArchiver is not None:
      self.__errArchiver.close()
      self.__removeZeroLengthFile(self.__errArchiver.getFilePath(), self.__errArchiver.getFileName())
      # need to check if file was removed before adding to export list..
      _fnameTmp = os.path.join(self.__errArchiver.getFilePath(), self.__errArchiver.getFileName())
      if os.path.exists(_fnameTmp):
        self.addExportedFile(_fnameTmp, delete=True)
      self.__errArchiver = None

    if self.__archiver is not None:
      self.__archiver.close()

      # Optional call back to perform processing once the archive file is closed
      # and before it gets exported.
      self.processArchive(os.path.join(self.__archiver.getFilePath(), self.__archiver.getFileName()))

    if self.prefs is not None:
      inShutDown = False
      if self.rc is not None and self.rc.inShutdown:
        inShutDown = True
      if not inShutDown:
        snapshotEnabled = 0
        if self.prefs.has_key("snapnbl"):
          snapshotEnabled = (int(self.prefs["snapnbl"]) == 1)
        if snapshotEnabled:
          self.__waitCursor()

          snFile = os.path.join(self.prefs["snapshotdir"],
                                "rsb" + self.__tstamp + ".xml")
          self.__snapResult["rsb"] = self.takeSnapshot(stream=None, fileName=snFile,
                                                        captureGTIC=1, captureGAEQ=1,
                                                        trigger=self.trigger())
          self.addExportedFile(snFile, delete=True)

          self.__normalCursor()

    # Let the operator override the completion status and add comments.
    if self.__common.options().securedir is not None or self.__common.options().paramverify is not None:
      if self.rc is not None and not self.rc.inShutdown:
        if not self.isRunFromSuite() or self.isLastSuiteScript():
          self.rc.execGUImethod(self.rc.handleEndRunDlg)

    # Create test report
    if self.rc is not None:
      if not self.rc.inShutdown:
        self.rc.execGUImethod(self.__genReport)
    else:
      self.__genReport()

    self.__logEndRun(fn)
    curDir = os.getcwd()
    self.__exportData()
    if os.path.exists(curDir):
      os.chdir(curDir)

  def __logEndRun(self, fn):
    log.info("%s -- Test %s finished, Run Id: %s, Status: %s, Completion Time: %s"
             % (fn, self.getName(), self.runId, self.getCompletionStatusStr(),
                time.asctime(time.gmtime(self.__endTime))))

    if int(self.prefs["lognbl"]) == 1:
      self.__common.stopRunLog(self.__runMsgLog)
      self.addExportedFile(self.__runMsgLogFile, delete=True)

  def processArchive(self, archivePath):
    """\brief Optional call back to perform processing on the archive file.

    This method will be called after the archive file is closed and before it is exported.
    User applications can override this method to perform custom processing on the file.

    \param archivePath Full path of the archive file.

    """
    pass

  def __calcDeadTime(self, temId=None):
    avgDeadTimes = {}
    if temId is None:
      tems = self.lat.TEM.keys()
    else:
      tems = [temId]
    for tId in tems:
      if tId in self.__deadtimeCtrReg and self.__startTime is not None:
        # Disable command debugging for status panel methods
        # which access hardware
        saveDebug = self.__cmdCli.getDebug()
        self.__cmdCli.setDebug(0)
        regNo = self.__deadtimeCtrReg[tId].id()
        try:
          resp = self.__deadtimeCtrReg[tId].getNode().read(regNo)
        except gException.LATInterfaceException, e:
          if e.errstr()[0] == 'OCS_TMO':  return {}
          else:                           raise
        newVal = resp.value()
        newTS = resp.payloads()[1]
        self.__cmdCli.setDebug(saveDebug)

        dTime = newVal - self.__deadTimeVal[tId]
        # Compensate for the non-running time.
        excludeTime = (time.time() - self.__startTime - self.__getElapsedTime()) * rcTransitions.TIMEBASE_RATE_IN_MHZ * 1000000
        dTS = newTS - self.__deadTimeTS[tId] - excludeTime
        if dTime < 0:
          dTime += (1L << 32)
        if dTS < 0:
          dTS += (1L << 64)
        if dTS != 0:
          avgDeadTime =  (float(dTime)/float(dTS))
          avgDeadTime *= (rcTransitions.TIMEBASE_RATE_IN_MHZ / rcTransitions.DEADTIME_RATE_IN_MHZ) * 100.0
        else:
          avgDeadTime = None
        avgDeadTimes[tId] = avgDeadTime
      else:
        avgDeadTimes[tId] = None
    return avgDeadTimes

  def __removeZeroLengthFile(self, filePath, fileName):
    fname = os.path.join(filePath, fileName)
    size = os.stat(fname)[6]
    if size == 0:
      try:
        os.remove(fname)
      except:
        return -1
    return 0

  def __exportData(self):
    """
      Routine to export all relevant data from a run to
      local storage and possibly to offsite backup.
      This routine is designed to execute after the completion of a run,
      but before teardown of Run Control.
      The name of the export directory is the run ID.  This is
      to guarantee against unintentional overwrites between multiple
      teststands.
    """

    # If we aren't exporting, return
    exportEnabled = (int(self.prefs["dataexport"]) == 1)
    if not exportEnabled: return

    # first thing is to create a local directory structure
    outDir = self.getRunId()
    outDirRoot = self.prefs["datadir"]
    outPath = os.path.join(outDirRoot,outDir)

    # Define two exporters.
    # One which purges the files after export, one which doesn't.
    hardExporter    = DataExport.DataExport()
    safeExporter    = DataExport.DataExport()
    hardExporter.setPurge(True)
    safeExporter.setPurge(False)

    # append to the list of exported files

    # schema configuration:  Don't delete these!
    self.addExportedFile(self.getSchemaConfigFile(), delete=False)
    if self.lat is not None:                    # additional files from GLAT...
      for f in self.lat._GLAT__includeFiles:
        self.addExportedFile(f, delete=False)

    if os.access(outDirRoot,os.W_OK):             # can we write?
      os.mkdir(outPath)

      # list of files that get hardExported.
      dataSave = (int(self.prefs["datasave"]) == 1)
      if dataSave:
        moveList = [ self.__archiver,    self.__fits ]
        for fileObj in moveList:
          if fileObj is not None:
            self.addExportedFile(os.path.join(fileObj.getFilePath(), fileObj.getFileName()), delete=True)

      # export housekeeping file
      # Change as per LTE-193
      #hskReadOnly = (int(self.prefs["envmonreadonly"]) == 1)
      #if self.__hsk is not None and (int(self.prefs["envmonnbl"]) == 1) and not hskReadOnly:
      #  self.addExportedFile(self.__hsk.getFileName(full=1), delete=True)

      # make the rcReport.out file
      rcLastLine = self.__rcLastLine()    # Grab the info from rcReport.out
      rcOutFile = open(os.path.join(outPath,"rcReport.out"), 'w')
      rcOutFile.write(rcLastLine)
      rcOutFile.close()

      for path,name,delete in self.__exportedFiles:
        try:
          if delete:
            hardExporter.export(os.path.join(path,name),os.path.join(outPath,name))
          else:
            safeExporter.export(os.path.join(path,name),os.path.join(outPath,name))
        except Exception, e:
          log.error("Exception %s in trying to export file %s" % (e, name))

    else: # Can't write to outDirRoot
      err = "rcTransitions.__exportData: Local directory ", outDirRoot, " is not writable"
      log.error(err)
      return         # Can't continue exporting, so return


    # if the data dir and the export dir are the same, don't export.
    if os.path.abspath(self.prefs["datadir"]) == os.path.abspath(self.prefs["exportdir"]):
      msg = "Data source and Export directories are identical\n" + \
            "source: %s, export: %s" % ( self.prefs["datadir"] , self.prefs["exportdir"] )
      log.warn(msg)
      exportEnabled = False

    # Export the directory to permanent storage
    if exportEnabled:
      if not os.path.exists(os.path.abspath(self.prefs["exportdir"])):
        log.fatal("Final export directory %s no longer exists.  Something has gone very, very wrong." % self.prefs["exportdir"])
        return

      destDir    = os.path.join(self.prefs["exportdir"] ,outDir)
      dbn = self.__common.getDBN()
      dbn['_LastExportPath'] = destDir
      sourceDir  = outPath
      hardExporter.export(sourceDir, destDir)

      # done export.  Create an "I'm done" file in the export area
      done = file(destDir+'/zzz.done','w')
      done.close()

  def __rcLastLine(self):
    """Get the last line of the run report file.
    """
    # Now, we need the info from rcReport.out
    # As this routine runs after the writing of the file, just grab
    # the last usable line.
    filename = ( os.path.join(self.prefs["reportdir"], 'rcReport.out') )

    rcFile = open(filename,'r')
    charsPerLine = 4096                         # this probably needs tuning.
    while 1:
      try:                                      # read from the end of the file
        rcFile.seek(-1 * charsPerLine ,2)
      except IOError:                           # the file's shorter than charsPerLine
        rcFile.seek(0)                          # reposition at head
      if rcFile.tell() == 0:
        atstart=True
      else:
        atstart=False

      rcLines=rcFile.read().split("\n")         # last line of file is blank,
      if (len(rcLines) > 2) or atstart:         # so require 2 full lines
        break
                                                # The lines are bigger than we thought,
      charsPerLine=charsPerLine * 2             # so double the read

    rcFile.close()
    rcLastLine = rcLines[len(rcLines)-2]        # cache this for later

    # extract the run id from rcLastLine, and compare it with what's expected
    import re
    runId = 0
    runIdRE = re.compile(r".*<RunId>(\d+)</RunId>.*")
    rList = runIdRE.findall(rcLastLine)
    if len(rList) > 0:
      runId = rList[0]
    else:
      log.fatal("Could not parse a run ID out of the last line of rcReport.out.")
      log.error("Last line = %s" % rcLastLine)
    if runId != self.getRunId():
      msg = "Run identifier read from rcReport.out (%s) does not match LATTE internal run ID (%s)" % (runId, self.getRunId())
      log.fatal(msg)


    return rcLastLine

  def selectEventHandler(self, type, customEventHandler = None):
    """Use this method to select an event handler to use.
    The application can call this method from the SETUP or START_RUN
    transitions.  If it doesn't, a default is used.
    """
    currentState = self.getState()
    if currentState is None:
      # Standalone mode - disable state check
      currentState = 'RESET'
    if currentState == 'RESET' or currentState == 'STOPPED':
      if type == rcTransitions.EVENT_HANDLER_STANDARD:
        self.__eventHandlerFn = self.__eventHandler
      elif type == rcTransitions.EVENT_HANDLER_LEAN_AND_MEAN:
        self.__eventHandlerFn = self.__datagramHandler
      elif type == rcTransitions.EVENT_HANDLER_PLAYBACK:
        self.__eventHandlerFn = self.__eventHandlerPlayback
      elif type == rcTransitions.EVENT_HANDLER_CUSTOM:
        self.__eventHandlerFn = customEventHandler
      else:
        log.error("Unrecognized eventHandler type")
    else:
      log.error("The event handler can not be changed in the %s state" % \
                (currentState))

# Private method for calling the application back with event data
  def __eventHandler(self):
    """Handler for calling the application back with event data
    """
    evtCli       = self.evtCli
    endRunMarker = rcTransitions.__SWEEP_MARKER

    # On playback, see if we need to trigger an event
    if self.__EBFplayback:
      # If application DIDN'T enable the internal trigger,
      # enable it and trigger first event
      if not self.trigger().conditions().solicited():
        playbackTrigger = True
        # two cases, GEM/GLT.
        # force an enable of the solicit in both cases.
        if self.lat.existsGEM():
          from LATTE.trigger.TrgGem import TrgGem
          self.trigger().enable(TrgGem._TrgGem__SOLICIT_MASK)
        else:
          from LATTE.trigger.TrgMiniGLT import TrgMiniGLT
          self.trigger().enable(TrgMiniGLT._TrgMiniGLT__SOLICIT_MASK)

        self.trigger().solicit()
      else:     # Application is taking care of triggering the event
        playbackTrigger = False

    self.__evtHandlerQuit = False

    # Indicate that the Event Handler is ready to take events
    self.__eventHandlerReady.set()

    while True:
      try:
        # Go wait for an event to show up
        status = evtCli.readEvent()
        if status == EvtCli.ABORT_ERROR:
          break

        # Count every event to ensure displayed rate makes sense
        self.evtCnt      += 1
        self.__dgSize     = evtCli.header[2]
        self.__dgSumSize += evtCli.header[2]

        # ST - We want to pass the event as is so that we can check what type
        #      of error it has in user script's process() method
        #parser_status = evtCli.readEvent()
        #if evtCli.checkOnlineStatus(parser_status, EvtCli.GGLT_STATUS_ERROR):
        #  status = evtCli.getGGLTStatus()
        #else:
        #  status = parser_status

        if (status == 0) or evtCli.checkOnlineStatus(status, EvtCli.PLAYBACK_ERROR):
          self.errorEvent = evtCli.isErrorEvent()
          self.trgParErrorEvent = evtCli.isTrgParityErrorEvent()
          self.packetErrorEvent = evtCli.isPacketErrorEvent()
          summaryMarker = evtCli.evt.summary.marker
          self.eventMarker = summaryMarker
          if summaryMarker == endRunMarker:
            self.__sweepEvent.set()     # Signal that the marked event was seen
            # Commented out, since we want the sweep marker event to be seen by process()
            #if self.__evtHandlerQuit:  break
            #continue

        # For efficiency first check whether event playback is enabled only once
        if self.__EBFplayback:
          # Whenever evtSvr detects errors during playback, stop the current run
          if evtCli.checkOnlineStatus(status, EvtCli.PLAYBACK_ERROR):
            self.rc.doStop()
            continue

          # Since we know we're in playback mode, trigger the next event if
          # the application DIDN'T enable the internal trigger
          if playbackTrigger:
            self.trigger().solicit()
          else:     # Application is taking care of triggering the event
            pass

        # Allow application to process all kinds of events
        #try:
          #self.process((status,evtCli.dat))
        latContribs = self.__process(status, evtCli.dat)
        #except:
        #  log.exception("")
        #  self.__appStatus = self.COMPL_STATUS_FAILED
        #  self.rc.doReset()

        # Policy: don't write out unnavigable or empty events
        if status != 0:
          self.__badEvents+=1
          if evtCli.dat is not None:
            try:
              self.__badArchiver.write(evtCli.dat)
            except AttributeError:
              # Archiver may be disabled by the --noerrfile option
              pass
        else:
          (l,) = struct.unpack('!L', evtCli.dat[4:8])
          if self.__fits is not None:
            self.__fits.write(evtCli.dat[:l])
          if self.errorEvent or self.packetErrorEvent or self.trgParErrorEvent:
            if summaryMarker != endRunMarker:
              try:
                self.__errArchiver.write(evtCli.dat[:l])
              except AttributeError:
                # Archiver may be disabled by the --noerrfile option
                pass
              # increment internal error counters
              if self.errorEvent:          self.__errEvents      += 1
              if self.trgParErrorEvent:    self.__trgParErrorEvt += 1
              if self.packetErrorEvent:    self.__pktErrorEvt    += 1

          self.__archive(evtCli.header[1], latContribs)
          #if self.__dds is not None:
          self.__publish(evtCli.dat)
      except IOError:
        # Handle the event timeout if enabled
        if str(sys.exc_info()[1]) == "Event read timeout":
          evtCli.dat = ''
          status = EvtCli.READ_TIMEOUT_ERROR
        else:
          self.trigger().disable()
          raise IOError, "Unhandled IOError in rcTransitions::readEvent: %s" % sys.exc_info()[1]

      if self.__evtHandlerQuit and self.__sweepEvent.isSet():  break

      # HEADS UP: At this point evtCli.dat could be byteswapped

    log.debug('rcTransitions.__eventHandler: %s terminating' % (self.getName()))


  def __archiveIt(self, datagramId, latContribs):
    # Calculate the length of the entire datagram
    size = 8                            # Datagram ID and its length
    for latContrib in latContribs:
      size += len(latContrib)

    # Create the datagram header
    dgHdr = struct.pack('>2L', datagramId, size)

    # Archive the datagram and all its contributions
    self.__archiver.writeTuple((dgHdr,) + latContribs)

  def __archiveDummy(self, datagramId, latContribs):
    pass

  def __archiveBad(self, datagram):
    archiver = self.__badArchiver
    if archiver is not None:
      archiver.write(datagram)

  def __archiveErr(self, datagram):
    archiver = self.__errArchiver
    if archiver is not None:
      archiver.write(datagram)

  def __publishIt(self, datagram):
    self.__dds.publish(datagram)

  def __publishDummy(self, datagram):
    pass

  def __process(self, status, datagram):
    try:
      # Make a copy of the whole event (not just a reference)
      # that proccess can byte swap.  - Revisit for efficiency
      #dgBuf = str(buffer(datagram))
      #import array
      #dgBuf = array.array('L', datagram).tostring()
      dgBuf = datagram[:1] + datagram[1:]

      latContribs = self.process((status, dgBuf))
      if latContribs is not None:  return latContribs
    except Exception, e:
      import logging
      logging.exception("Trapped userApplication:process() exception: %s" % e)
      self.__appStatus = self.COMPL_STATUS_FAILED
      self.rc.doReset()

    # RiC: The following may be a better solution to the copy done above
    # if datagram[0:4] == LDF.LATdatagram.ID:  datagram.byteswap()

    return (datagram[8:],)        # LATcontributions, not LATdatagrams

  def __datagramHandler(self):
    """Handler for calling the application back with event datagrams
    """

    sweepEvt  = self.__sweepEvent
    evtCli    = self.evtCli
    sweepMkr  = rcTransitions.__SWEEP_MARKER
    markerMsk = 0x7 << 22
    errorMsk  = 0x1 << 21
    trgParMsk = 0x1
    pktErrMsk = 0x7 << 13  #

    self.__evtHandlerQuit = False

    # Indicate that the Event Handler is ready to take events
    self.__eventHandlerReady.set()

    while not (self.__evtHandlerQuit and sweepEvt.isSet()):

      # Get the data from the socket
      header, datagram = evtCli.readSocket()

      # Count every event to ensure displayed rate makes sense
      self.evtCnt      += 1
      self.__dgSize     = header[2]
      self.__dgSumSize += header[2]

      # Give application quick access to error bit and marker
      self.errorEvent       = (header[6] & errorMsk) != 0
      self.trgParErrorEvent = (header[6] & trgParMsk )
      self.packetErrorEvent = ( (header[5] & pktErrMsk) != 0 )
      self.eventMarker      = (header[6] & markerMsk) >> 22


      # Process the datagram
      latContribs = self.__process(header[0], datagram)

      # Check FSW event delivery to OES status
      if header[0] == 0:
        # Archive the data
        self.__archive(header[1], latContribs)

        # Multicast the data
        self.__publish(datagram)

        # Handle datagrams with TEM contribution errors
        if self.eventMarker != sweepMkr and \
            (self.errorEvent or self.trgParErrorEvent or self.packetErrorEvent):
          self.__archiveErr(datagram)
          # increment internal error counters
          if self.errorEvent:          self.__errEvents      += 1
          if self.trgParErrorEvent:    self.__trgParErrorEvt += 1
          if self.packetErrorEvent:    self.__pktErrorEvt    += 1
      else:
        # Handle datagrams for which FSW choked
        self.__badEvents += 1
        self.__archiveBad(datagram)

      # Make sure the above is done before setting the sweepEvt to prevent
      # things from getting out of synch.
      if self.eventMarker == sweepMkr:  sweepEvt.set()

    log.debug('rcTransitions.__datagramHandler: %s terminating' %
              (self.getName()))


  def __eventHandlerPlayback(self):
    """Handler for calling the application back with played back event data
    """
    pass # Currently handled by __eventHandler() above

  def publishConsumerDG(self, buf):
    import LDF
    # Pad the contributions with zeros to force it to be an integer number of
    # longwords in length
    remainder = len(buf) & 0x3
    if remainder:  buf += "\x00\x00\x00"[0:4-remainder]
    # need to byteswap the raw buffer if little endian
    if sys.byteorder == "little":
      import array
      buf = array.array('L',buf)
      buf.byteswap()
      buf = buf.tostring()
    # get type for this UDF contribution
    # pending definition of this contribution, use Scratch
    primary   = LDF.LATprimaryId().Base_Scratch
    secondary = LDF.LATsecondaryId().Base_Scratch
    typeId = LDF.LATtypeId(primary, secondary)
    # construct header
    dg = LDF.LATdatagram()
    # 8's are to accomodate pairs of long words of the UDF heade
    # opaque is length of my contribution with header in bytes
    dg = struct.pack('>4L',dg.ID,len(buf)+len(dg)+8,typeId.value(),len(buf)+8)
    dg = dg+str(buf)
    self.__publish(dg)
    time.sleep(0.05)

  class ApplicationCallbacks(object):
    def beforeSetup(self, app):
      pass
    def afterSetup(self, app):
      pass
    def beforeStartRun(self, app):
      pass
    def afterStartRun(self, app):
      pass
    def beforeStopRun(self, app):
      pass
    def afterStopRun(self, app):
      pass
    def beforeTeardown(self, app):
      pass
    def afterTeardown(self, app):
      pass

  class StandaloneLauncher(object):
    def __init__(self, logLevel="INFO"):
      self.__common = RunControlCommon()
      self.__common.initialize()
      self.__common.setLoggingLevel(logLevel)
      self.__common.connect()

    def launch(self, appClass, user, callbacks=None):
      if appClass is None:
        module = self.__common.options().app
        try:
          (module, filename) = rcUtil.importModule(module, reload=0)
        except Exception, e:
          log.exception(e)
          return
        ua = module.userApplication(None, user, self.__common)
        if callbacks is None and 'userApplicationCallbacks' in dir(module):
          callbacks = module.userApplicationCallbacks()
      else:
        ua = appClass(None, user, self.__common)

      if callbacks is not None:
        callbacks.beforeSetup(ua)
      ua.rcSetup()
      if callbacks is not None:
        callbacks.afterSetup(ua)
      if callbacks is not None:
        callbacks.beforeStartRun(ua)
      ua.rcStartRun()
      if callbacks is not None:
        callbacks.afterStartRun(ua)
      ua.wait()
      if callbacks is not None:
        callbacks.beforeStopRun(ua)
      ua.rcStopRun()
      if callbacks is not None:
        callbacks.afterStopRun(ua)
      if callbacks is not None:
        callbacks.beforeTeardown(ua)
      ua.rcTeardown()
      if callbacks is not None:
        callbacks.afterTeardown(ua)

---