rcSuite.py

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

__facility__ = "Online"
__abstract__ = "GLAST LAT run control suite execution framework"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/10/26 01:46:50 $").split(' ')[1]
__version__  = "$Revision: 2.22 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import threading
import logging  as log
import types
import copy

import rcUtil
from RunControlCommon import RunControlCommon

class rcSuite(object):

  class StopRequestedException(Exception):
    def __init__(self,msg,suite,module):
      self.args = (msg, suite, module)
      self.msg = msg
      self.suite = suite
      self.module = module

  class SuiteCallbacks(object):
    def beforeSetupSuite(self, suite):
      pass
    def afterSetupSuite(self, suite):
      pass
    def beforeStartSuite(self, suite):
      pass
    def afterStartSuite(self, suite):
      pass
    def beforeStopSuite(self, suite):
      pass
    def afterStopSuite(self, suite):
      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, suiteClass, user, callbacks=None):
      if suiteClass is None:
        module = self.__common.options().app
        try:
          (module, filename) = rcUtil.importModule(module, reload=0)
        except Exception, e:
          log.exception(e)
          return
        us = module.userSuite(self, user, self.__common)
        if callbacks is None and 'userSuiteCallbacks' in dir(module):
          callbacks = module.userSuiteCallbacks()
      else:
        us = suiteClass(self, user, self.__common)
      if callbacks is not None:
        callbacks.beforeSetupSuite(us)
      us.rcSetupSuite()
      if callbacks is not None:
        callbacks.afterSetupSuite(us)
      if callbacks is not None:
        callbacks.beforeStartSuite(us)
      us.rcStartSuite(spawn=0)
      if callbacks is not None:
        callbacks.afterStartSuite(us)
      if callbacks is not None:
        callbacks.beforeStopSuite(us)
      us.rcStopSuite()
      if callbacks is not None:
        callbacks.afterStopSuite(us)

    def doStopRun(self):
      pass

    def preferences(self):
      return self.__common.prefMan().preferences()

    def common(self):
      return self.__common


  def __init__(self, gui, userId, debug):
    log.debug("rcSuite.__init__()")

    self.__userId      = userId
    self.__debug       = debug
    self.__cmdCli      = None
    self.__evtCli      = None

    #self.__modules     = []
    #self.__schemas     = []
    self.__isOKtoQuitOrPause  = threading.Event()
    self.__cmdQuit     = 0
    self.__paused      = False
    self.__running     = False
    self.__app         = None
    self.__scriptSeq   = 0
    self.__suite       = None
    self.__suiteInst   = None
    self.__state       = 'RESET'
    self.__appState    = 'RESET'
    # Flag to indicate that there was an exception in the running script.
    self.__reset       = False

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

    if self.__debug.__class__.__name__ == 'RunControlCommon':
      self.__common = self.__debug
      self.__statMon = None
    else:
      self.__common = self.gui.common()
      self.__statMon = self.gui.statusMonitor()

    # Expose the schema to the suite
    self.lat = self.getSessionVar('_LATSchema')
    self.xbrd = self.getSessionVar('_XBRDSchema')

#  def addApplication(self, appName, schema):
#    try:
#      (module, filename) = rcUtil.importModule(appName, reload=0)
#    except Exception:
#      gutil.logException()


#    if 'userApplication' not in dir(module):
#      msg = 'Application %s is missing a userApplication class' % appName
#      log.error(msg)
#      return msg

#    log.info("Application loaded from %s" % filename)
#    self.__modules.append(module)
#    self.__schemas.append(schema)

  def setupSuite(self):
    """ Override this method to do custom processing before the suite is started and/or
    to return a custom schema file
    """
    return None

  def rcPauseSuite(self):
    fn = "rcSuite.rcPauseSuite"
    log.debug("%s -- %s" % (fn, self.getName()))
    if self.__paused:
      return -1
    if self.pauseSuite() is not None:
      return
    if self.__app is not None:
      if self.__app.__class__.__name__ == 'userApplication':
        self.__isOKtoQuitOrPause.wait()
        if self.__app is not None and self.__app.rcPause() is None:
          self.__paused = True
          return None
      else:
        if self.__app.rcPauseSuite() is None:
          self.__paused = True
          return None
    return -1

  def pauseSuite(self):
    """ Override this method to do custom processing before the currently running
    application is paused. Pause can be rejected by not returning None
    """
    return None


  def rcSetupSuite(self):
    """ This method can be called from either RunControlMain or from another suite.
    """
    fn = "rcSuite.rcSetupSuite"
    log.debug("%s -- %s" % (fn, self.getName()))

    #askForSchema = 0
    #if schema is None:
    #  reuseSchema = self.getSessionVar('_reuseSchema')
    #  schema = self.getSessionVar("_suiteLATSchemaFile")
    #  if not reuseSchema:
    #    askForSchema = 1

    #if askForSchema:
    #  scmCfg = self.gui.createGUI(rcScmCfgSelector.rcScmCfgSelector, self.gui.common().preferences()['reposdir'],
    #                              schema, self.gui, 'ScmCfgSelector')
    #  scmCfgFile = scmCfg.getValue()
    #  # Allow the C++ object to be deleted
    #  scmCfg.deleteLater()
    #  if scmCfgFile is None or os.path.splitext(scmCfgFile.lower())[1] != '.xml':
    #    if scmCfgFile is not None:
    #      log.error("%s: Invalid SchemaConfig filename '%s'" % (fn, scmCfgFile))
    #    schema = None
    #  else:
    #    self.setSessionVar("_LATSchemaFile", scmCfgFile)
    #    self.setSessionVar("_suiteLATSchemaFile", scmCfgFile)
    #    schema = scmCfgFile

    #if schema is not None:
    #  self.setupSuite()
    #else:

    #return schema

    self.setupSuite()
    return 0

  def rcStartSuite(self, spawn=1):
    fn = "rcSuite.rcStartSuite"
    log.debug("%s -- %s" % (fn, self.getName()))
    if self.__running and not self.__paused:
      return -1
    self.__scriptSeq = 0
    self.__running = True
    self.__state = 'RUNNING'
    if self.__paused:
      if self.__app.__class__.__name__ == 'userApplication':
        if self.__app.rcResume() is None:
          self.__paused = False
      else:
        self.__app.rcStartSuite()
    else:
      self.__cmdQuit = 0
      if spawn:
        self.__suiteRun = threading.Thread(group=None, name="SuiteThread", target=self.startSuite)
        self.__suiteRun.start()
      else:
        self.startSuite()

  def stopSuite(self):
    """ Override this method to do custom processing before the suite is terminated
    """
    pass

  def rcStopSuite(self):
    fn = "rcSuite.rcStopSuite"
    log.debug("%s -- %s" % (fn, self.getName()))
    if self.stopRequested():
      self.__running = False
      return
    if self.__app is not None and self.__app.__class__.__name__ == 'userApplication':
      self.__isOKtoQuitOrPause.wait()
    self.__cmdQuit = 1
    if self.__app is not None:
      if self.__app.__class__.__name__ == 'userSuite':
        self.__app.rcStopSuite()
      else:
        if self.__paused:
          if self.__app.rcResume() is None:
            self.__paused = False
            self.__app.rcStopRun()
            self.__app.rcTeardown()
        else:
          self.__app.rcStopRun()
          self.__app.rcTeardown()
    self.stopSuite()
    self.__running = False
    self.__state = 'RESET'
    #self.__suiteRun.join()

  #def __suiteRunThread(self):
  #  i = 0
  #  for module in self.__modules:
  #    self.scriptRun(module, self.__schemas[i])
  #    if self.__cmdQuit: break
  #    i += 1

  def scriptRun(self, module, context={}):
    fn = "rcSuite.scriptRun"
    log.debug("%s: %s" % (fn, module))
    self.__scriptSeq += 1
    if self.stopRequested():
        raise rcSuite.StopRequestedException("Operator requested stop of execution",
                                            self.getName(),
                                            ""
                                            )
    self.__isOKtoQuitOrPause.clear()
    for (key, value) in context.items():
      self.setSessionVar(key, value)
    if type(module) is types.StringType:
      if self.__statMon is not None:
        self.gui.execGUImethod(self.__statMon.stopWatch)
      try:
        (module, filename) = rcUtil.importModule(module, reload=0)
      except Exception, e:
        log.exception(e)
        if self.__statMon is not None:
          self.gui.execGUImethod(self.__statMon.startWatch)
        return None
      if self.__statMon is not None:
        self.gui.execGUImethod(self.__statMon.startWatch)
    self.__reset = False
    if 'userApplication' in dir(module):
      if self.__debug.__class__.__name__ == 'RunControlCommon':
        self.__app = module.userApplication(None, self.__userId,
                                            self.__debug )
      else:
        self.__app = module.userApplication(self.gui, self.__userId,
                                            self.__debug )
      self.__app.setSuite(self.getName())
      self.__app.setSuiteInstance(self)
      self.__app.setCmdCli(self.__cmdCli)
      if self.__app.getEvtCli() is None:
        self.__app.setEvtCli(self.__evtCli)
      self.__appState = 'RESET'
      if self.__app.rcSetup() is not None:
        self.__cmdQuit = 1
        raise rcSuite.StopRequestedException("setup() is rejected, stopping suite execution",
                                            self.__app.getSuite(),
                                            self.__app.getName()
                                            )
      self.__appState = 'STOPPED'
      status = self.__app.rcStartRun()
      self.__appState = 'RUNNING'
      self.__isOKtoQuitOrPause.set()
      if status is not None:
        self.__cmdQuit = 1
        raise rcSuite.StopRequestedException("startRun() is rejected, stopping suite execution",
                                            self.__app.getSuite(),
                                            self.__app.getName()
                                            )
      self.__app.wait()
      if self.stopRequested():
        raise rcSuite.StopRequestedException("Operator requested stop of execution",
                                            self.__app.getSuite(),
                                            self.__app.getName()
                                            )
      self.__isOKtoQuitOrPause.wait()
      self.__isOKtoQuitOrPause.clear()
      if not self.__reset:
        self.__app.rcStopRun()
        self.__app.rcTeardown()
      self.__appState = 'RESET'
      del self.__app
      self.__app = None
      self.__isOKtoQuitOrPause.set()
    elif 'userSuite' in dir(module):
      self.__app = module.userSuite( self.gui, self.__userId, self.__debug)
      log.info("Suite %s loaded from %s" % (self.__app.getName(), filename))
      self.__app.setCmdCli(self.__cmdCli)
      self.__app.setEvtCli(self.__evtCli)
      #if self.__app.rcSetupSuite(self.getSessionVar("_suiteLATSchemaFile")) is None:
      #  log.error("Suite setup failed...Aborting suite %s" % self.__app.getName())
      #  return
      #else:
      self.__app.setSuite(self.getName())
      self.__app.setSuiteInstance(self)
      self.__app.rcSetupSuite()
      self.__app.rcStartSuite(spawn=0)
      self.__isOKtoQuitOrPause.set()
        #self.__app.rcStopSuite()
        #self.__app = None
    else:
      errorMsg = '%s is not a recognized user script. userApplication or userSuite class missing' % module
      log.error(errorMsg)
      raise RuntimeError, errorMsg
    return self.__copySessionVars()

  def resetSuiteScript(self):
    if self.__app.__class__.__name__ == 'userApplication' and not self.stopRequested():
      self.__isOKtoQuitOrPause.clear()
      self.__reset = True
      if 'sync' in dir(self.__app):
        self.__app.sync()
      self.__app.rcStopRun()
      self.__app.rcTeardown()
      self.__isOKtoQuitOrPause.set()

  def setCmdCli(self, cmdCli):
    self.__cmdCli = cmdCli

  def setEvtCli(self, evtCli):
    self.__evtCli = evtCli

  def getEvtCli(self):
    return self.__evtCli

  def isSuiteScriptAborted(self):
    return self.__reset

  def getScriptSequence(self):
    return self.__scriptSeq

  def getScriptState(self):
    """\brief Return the state of the suite script.

    Currently there are two states. 'RESET' or 'RUNNING'.
    If rcSetupSuite or rcStopSuite has completed execution then
    the state will be 'RESET'. If rcStartSuite started execution
    then the state will be 'RUNNING'.

    \return 'RESET' or 'RUNNING'
    """
    return self.__state

  def getAppState(self):
    """\brief Return the state of the current script.

    \return State of the current script
    """
    return self.__appState

  def getApp(self):
    """\brief Return the instance of current script.

    Returns the instance for the suite script or nested suite
    that is currently executing.

    \return userApplication or userSuite instance.
    """
    return self.__app

  def getSuite(self):
    """\brief Get the parent suite name of this suite

    \return Parent suite name or None.
    """
    return self.__suite

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

    \param name Parent suite name
    """
    self.__suite = name

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

    \return Parent suite instance.
    """
    return self.__suiteInst

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

    \param suiteInst Parent suite instance.
    """
    self.__suiteInst = suiteInst

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

    Do not use variable names beginning
    with the underscore ('_') character since these are reserved for RunControl
    """
    sessionVars = self.__common.getDBN()
    if sessionVars is not None:
      sessionVars[key] = value
    else:
      raise RuntimeError, "Database node does not exist"

  def getSessionVar(self, key):
    """Retrieve the values of the session variable indicated by \a key.

    \return Session variable value
    """
    sessionVars = self.__common.getDBN()
    if sessionVars is not None and sessionVars.has_key(key):
      return sessionVars[key]
    else:
      return None

  def __copySessionVars(self):
    newCopy = {}
    vars = self.__common.getDBN()
    for varName in vars.keys():
      if varName.startswith('_'): continue
      try:
        newCopy[varName] = copy.deepcopy(vars[varName])
      except:
        newCopy[varName] = copy.copy(vars[varName])
    return newCopy

  #def readSchema(self, scmCfgFile):
  #  fn = "rcTransitions.readSchema"
  #  lat = gSchemaConfig.readSchema(scmCfgFile)
  #  if lat is None:
  #    log.error("%s: Unable to instatiate a LAT from SchemaConfig file '%s'" % \
  #              (fn, scmCfgFile))
  #    return None
  #  includeFiles = lat._GLAT__includeFiles
  #  incFileModTime = {}
  #  for f in includeFiles:
  #    incFileModTime[f] = os.path.getmtime(f)
  #  lat.setCmd(self.__cmdCli)
  #  self.setSessionVar('_LATSchema', lat)
  #  self.setSessionVar('_LATSchemaFile', scmCfgFile)
  #  self.setSessionVar('_LATSchemaFileModTime', os.path.getmtime(scmCfgFile))
  #  self.setSessionVar('_LATIncludeFileModTime', incFileModTime)
  #  return lat

  def readSchema(self, scmCfgFile):
    self.__common.readSchema(scmCfgFile)

  def applyConfig(self, seq=None, gxbrd=None):
    if self.lat is not None:
      self.lat.applyConfig(seq, gxbrd)

  def stopRequested(self):
    return self.__cmdQuit

  def clearStopRequested(self):
    self.__cmdQuit = 0

  def isPaused(self):
    return self.__paused

  def isRunning(self):
    return self.__running

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

  def startSuite(self):
    raise RuntimeError, "Suite does not define a startSuite method"

---