excApp.py

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

__facility__ = "Online"
__abstract__ = "Application for testing handling of exceptions"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "August 20, 2004"        # Created
__version__  = "$Revision: 1.1 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from qt import qApp

import            threading
import logging as log

from   LATTE.runcontrol.rcTransitions  import rcTransitions
from   LATTE.runcontrol.ArgumentImpl   import ArgumentImpl

from support.SimpleGasuExample   import *
from support.MiniGLTExample      import *


#  This class puts up a GUI for inputting a value of some sort.  It is used by
#  the userApplication example to get the number of self triggers to take.
class userArgument(ArgumentImpl):
  "GUI for getting the user to input some sort of value."
  def __init__(self, parent = None, name = None, modal = 0, fl = 0):
    ArgumentImpl.__init__(self, parent, name, modal, fl)
    self.__value = 0

  def OKButtonClicked(self):
    self.__value = int(self.ArgumentList.text().latin1())
    self.close()

  def CancelButtonClicked(self):
    self.__value = None
    self.close()

  def getValue(self, caption):
    #self.setCaption(caption)
    self.ArgLabel.setText(qApp.translate("Argument", caption, None))
    self.show()
    self.exec_loop()
    return self.__value

  def getValueExc(self, caption):
    raise Exception, "Exception taken during a GUI operation"

class userArgText(object):
  "Text user interface for getting the user to input some sort of value"
  def __init__(self):
    pass

  def getValue(self, caption):
    return int(raw_input("%s: " % (caption)))


#  Null application implementation.
class userApplication(rcTransitions):
  "Implmentation class for Null application"
  def __init__(self, rc, userId, debug):
    rcTransitions.__init__(self, rc, userId, debug)
    self.__eventSem    = threading.Semaphore(0)
    self.__cmdSynchSem = threading.Semaphore(0)

  def getName(self):
    return __name__

  def setup(self):
    log.debug("userApplication.setup()")

    if self.rc is None:
      self.__arg = userArgText()
    else:
      self.__arg = self.rc.createGUI(userArgument, self.rc, self.getName(), 1)

    caption = "Select when to take an exception:\n  0 = GUI\n  1 = Setup\n  2 = StartRun\n  3 = StopRun\n  4 = Stop\n  5 = Teardown\n  6 = Pause\n  7 = Resume\n  8 = CmdSynch\n  9 = Process"
    if self.rc is None:
      self.__state = self.__arg.getValue(caption)
    else:
      self.__state = self.rc.execGUImethod(self.__arg.getValue, caption)

    if self.__state == 0:
      crud = self.rc.execGUImethod(self.__arg.getValueExc, "Exception test")
      return False                      # To reject the transition

    if self.__state == 1:
      raise Exception, "Exception taken during SETUP transition"

    # Two choices for the trigger, GEM and MiniGLT
    if self.lat.existsGEM():
      self.trigger( SimpleGasuExample() )
    else:
      self.trigger( MiniGLTExample() )

    # A state transition can be rejected by not returning None
    return None

  def startRun(self):
    log.debug("userApplication.startRun()")

    if self.__state == 2:
      raise Exception, "Exception taken during STARTRUN transition"

    self.__cmdSynchQuit = False

    # A state transition can be rejected by not returning None
    return None

  def stopRun(self):
    log.debug("userApplication.stopRun()")

    self.__cmdSynchQuit = True
    self.__eventSem.release()

    # Set the test completion status value
    self.setCompletionStatus(self.COMPL_STATUS_PASSED)

    if self.__state == 3:
      raise Exception, "Exception taken during STOPRUN transition"

    # The STOP_RUN transition can not be rejected

  def stop(self):
    log.debug("userApplication.stop()")

    if self.__state == 4:
      raise Exception, "Exception taken during STOP transition"

    return self.stopRun()

  def teardown(self):
    log.debug("userApplication.teardown()")

    if self.__state == 5:
      raise Exception, "Exception taken during TEARDOWN transition"

  def pause(self):
    log.debug("userApplication.pause()")

    if self.__state == 6:
      raise Exception, "Exception taken during PAUSE transition"

  def resume(self):
    log.debug("userApplication.resume()")

    if self.__state == 7:
      raise Exception, "Exception taken during RESUME transition"

    # Issue self trigger to make up for the one that was lost during PAUSE
    self.trigger().solicit()

  def process(self, (status, buffer)):
    "Method called back for each data event taken"

    if self.__state == 8:  log.debug("userApplication.process()")

    if self.__state == 9:
      raise Exception, "Exception taken during process()"

    # Get next event triggered
    self.__eventSem.release()

  def commandSynch(self):
    log.debug("userApplication.commandSynch()")

    trigger  = self.trigger()
    eventSem = self.__eventSem

    # Drain the semaphore release count
    # Handles the case when the stop run release collided with a trigger release
    while eventSem.acquire(0):  pass

    # Wait for START_RUN to enable triggers
    trigger.waitForMaskEnable()

    cnt = 0
    while not self.__cmdSynchQuit:
      if cnt == 5 and self.__state == 8:
        raise Exception, "Exception taken during commandSynch()"
      trigger.solicit()                 # Issue an internal trigger
      eventSem.acquire()                # Wait for the event to be processed
      cnt += 1

    # Indicate we're done
    self.sync()

  def wait(self):
    self.__cmdSynchSem.acquire()

  def sync(self):
    if __name__ == "__main__" or self.isRunFromSuite():
      self.__cmdSynchSem.release()


# Standalone mode:
if __name__ == "__main__":
  import os
  import logging as log
  log.basicConfig()
  log.getLogger("").setLevel(log.DEBUG)
  ua = userApplication(None, 321, 0)
  prefs = {'datasave': 1, 'datadir':os.path.join(os.environ['ONLINE_ROOT'],'temp')}
  ua.setPrefs(prefs)
  ua.rcSetup(os.path.join(os.environ['ONLINE_ROOT'], 'repos/simpleTemSchema.xml'))
  ua.rcStartRun()
  ua.wait()
  ua.rcStopRun()
  ua.rcTeardown()

# History:
#     $Log: excApp.py,v $
#     Revision 1.1  2004/08/23 21:04:24  claus
#     Test exception handling.
#
#

---