RunControl.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 class"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "10/11/2002"
__version__  = "$Revision: 2.5 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC


import                          os
import                          sys
import                          atexit
import                          threading
import logging           as     log
from   qt                import *

from   Queue             import Queue
from   RunControlFSM     import RunControlFSM
from   RunControlGUIImpl import RunControlGUIImpl

from   LATTE.database.gVersions import Gversions
from   LATTE.tools.guiBridges   import QtThreadBridge, PyThreadBridge
from   LATTE.client.gLog        import logException
from   LATTE.tools.taskEngine   import TaskEngine


class ConnectState:
  Disconnected = 0
  Waiting      = 1
  Connected    = 2

class RunControl(RunControlGUIImpl):
  """Class for providing a run control framework
  """

  GUI_CMD_INST    = QEvent.Type(QEvent.User + 1)
  GUI_CMD_FUNC    = QEvent.Type(QEvent.User + 2)
  GUI_CMD_FUNC_NR = QEvent.Type(QEvent.User + 3)

  def __init__(self, common, parent = None, name = None, fl = 0):
    RunControlGUIImpl.__init__(self, common, parent, name, fl)

    self.gui      = self                # For backward compatibility

    self.__common       = common
    self.__fsm          = None
    self.__actionEngine = None
    self.__hwVersions   = None
    self.__queue        = None
    self.__engine       = None

    # Set this object to be the client handler
    common.getCmdCli().handler(self)
    self.__connection_state = ConnectState.Disconnected
    #self.StopButton.setEnabled(False)
    #self.RunButton.setEnabled(False)
    #self.PauseButton.setEnabled(False)

    # Set up the GUI bridge
    self.initGUIbridges()

    self.__actionEngine = TaskEngine("FSMactionEngine")
    self.__actionEngine.start()

    self.commandSynch = TaskEngine("CommandSynch")
    self.commandSynch.start()

    self.eventHandler = TaskEngine("EventHandler")
    self.eventHandler.start()

    # Clean up at exit
    self.inShutdown = False
    atexit.register(self.__shutdown)

  def disconnected(self):
    self.__disconnect()

  def timedout(self):
    self.__disconnect()

  def __connection_notthere(self): # GUI thread
    #self.StopButton.setEnabled(False)
    #self.RunButton.setEnabled(False)
    #self.PauseButton.setEnabled(False)
    if self.__connection_state == ConnectState.Connected:
      log.error("OCS server disconnected, trying to reconnect")
      self.__connection_state = ConnectState.Waiting
      self.__common.disconnect() # RiC
      self.__connect()

  def __connection_established(self): # GUI thread
    log.info("OCS server is now connected")
    #self.StopButton.setEnabled(True)
    #self.RunButton.setEnabled(True)
    #self.PauseButton.setEnabled(True)
    self.__connection_state = ConnectState.Connected

  def __connection_failed(self, msg): # GUI thread
    if self.__tries == 0:
      log.error(msg)
    self.__tries += 1
    return self.__connection_state

  def connectClicked(self): # GUI thread
    if self.__connection_state is ConnectState.Disconnected:
      self.fileConnectAction.setMenuText("Disconnect")
      self.__connection_state = ConnectState.Waiting
      self.__tries = 0
      self.__connect()
    else:
      self.fileConnectAction.setMenuText("Connect")
      self.__connection_state = ConnectState.Disconnected
      self.__disconnect()

  def __connect(self):
    connecthdlr = threading.Thread(None, self.__connection_handler, 'ConnectHandler',())
    connecthdlr.setDaemon(True)
    connecthdlr.start()

  def __disconnect(self):
    self.execGUImethod(self.__connection_notthere)

  def __connection_handler(self):
    while (True):
      try:
        self.__common.connect()
        self.execGUImethodNR(self.__connection_established)
        break
      except RuntimeError, msg:
        state = self.execGUImethod(self.__connection_failed, msg)
        if state == ConnectState.Disconnected: break
        time.sleep(3)

  def userId(self):
    return 43231  #self.preferences()["userid"]

  def __statusMsg(self, msg, tmo):
    self.statusBar().message(msg, tmo)

  def __shutdown(self):
    """\brief Clean up and shut down the various threads.
    """
    # This method expects to be executed from the GUI thread.

    self.inShutdown = True

    # Bring the system into the RESET state
    self.doReset()

    # Use the following non-NR call to wait for the reset to finish
    self.execGUImethod(self.statusBar().message, "Exiting")

    # Shut down the task engines
    self.__actionEngine.shutdown()
    self.eventHandler.shutdown()
    self.commandSynch.shutdown()

    # After the FSM Action Engine has shut down we can delete the FSM
    if self.__fsm:
      del self.__fsm
      self.__fsm = None

  def __start(self, applName):
    ## Import the application
    #(appPath, appFile) = os.path.split(applName)
    #(appBase, appExt)  = os.path.splitext(appFile)
    #appStuff = self.__bml.find_module(appBase, (appPath,))
    #if appStuff is None:
    #  msg = 'Application %s is invalid' % applName
    #  logging.error(msg)
    #  return msg
    #module = self.__bml.load_module(appBase, appStuff)
    #if 'userApplication' not in dir(module):
    #  msg = 'Application %s is missing a userApplication class' % applName
    #  logging.error(msg)
    #  return msg

    import rcUtil
    try:
      dontReloadList = self.__common.options().noreload
      (module, filename) = rcUtil.importModule(appName=applName, reload=1, dontReloadList=dontReloadList)
    except Exception, e:
      logException()
      self.execGUImethodNR(self.__statusMsg, e[0], 0)
      return

    # Instantiate the application
    app = module.userApplication(self, self.__common.prefMan().userId(),
                                 self.__common.options().evtdebug is not None)
    log.info("Application %s loaded" % app.getName())

    # Set up the Finite State Machine
    self.__fsm = RunControlFSM(app)

    self.execGUImethodNR(self.__statusMsg, '%s: Loaded application %s' %
                         (self.__fsm.current_state, applName), 0)

  def SetupClicked(self):
    RunControlGUIImpl.SetupClicked(self)
    self.__actionEngine.spawn(self.__setup)

  def __setup(self):
    if self.__fsm is not None:
      self.__fsm.process('SETUP')
      self.__statusMsg(self.__fsm.current_state, 0)

  def TeardownClicked(self):
    RunControlGUIImpl.TeardownClicked(self)
    self.__actionEngine.spawn(self.__teardown)

  def __teardown(self):
    if self.__fsm is not None:
      self.__fsm.process('TEARDOWN')
      self.__statusMsg(self.__fsm.current_state, 0)

  def StartRunClicked(self):
    RunControlGUIImpl.StartRunClicked(self)
    self.__actionEngine.spawn(self.__run)

  def __run(self):
    if self.__fsm is not None:
      self.__fsm.process('START_RUN')
      self.__statusMsg(self.__fsm.current_state, 0)

  def StopRunClicked(self):
    RunControlGUIImpl.StopRunClicked(self)
    self.__actionEngine.spawn(self.__stoprun)

  def __stoprun(self):
    if self.__fsm is not None:
      self.__fsm.process('STOP_RUN')
      self.__statusMsg(self.__fsm.current_state, 0)

  def PauseClicked(self):
    RunControlGUIImpl.PauseClicked(self)
    self.__actionEngine.spawn(self.__pause)

  def __pause(self):
    if self.__fsm is not None:
      self.__fsm.process('PAUSE')
      self.__statusMsg(self.__fsm.current_state, 0)

  def ResumeClicked(self):
    RunControlGUIImpl.ResumeClicked(self)
    self.__actionEngine.spawn(self.__resume)

  def __resume(self):
    if self.__fsm is not None:
      self.__fsm.process('RESUME')
      self.__statusMsg(self.__fsm.current_state, 0)

  def StopClicked(self):
    RunControlGUIImpl.StopClicked(self)
    self.__actionEngine.spawn(self.__stop)

  def __stop(self):
    if self.__fsm is not None:
      self.__fsm.process('STOP')
      self.__statusMsg(self.__fsm.current_state, 0)


  def load(self):
    if self.__fsm is not None and self.__fsm.current_state != 'RESET':
      print "Applications are loadable only in the RESET state"
      self.__statusMsg('%s: Applications are loadable only in the RESET state' %
                       (self.__fsm.current_state), 0)
      return

    applName = RunControlGUIImpl.load(self)
    if applName is None:
      if self.__fsm is not None:
        self.__statusMsg('%s: Loading aborted' % (self.__fsm.current_state), 0)
      else:
        self.__statusMsg('Loading aborted', 0)
      return

    if self.__fsm is not None:
      self.__shutdown()

    # Start the application in its own thread after the reset from above
    # (if any) completes.
    self.__actionEngine.spawn(self.__start, str(applName))

    #msg = self.__start(str(applName))
    #if msg is None:
    #  self.__statusMsg('%s: Loaded application %s' %
    #                   (self.__fsm.current_state, applName), 0)
    #else:
    #  self.__statusMsg(msg, 0)

  def fileExit(self):
    self.close()

  def ExitButtonClicked(self):
    self.close()

  def doReset(self):
    """Emit a Reset button click under program control.
    Can be done from a subthread."""
    self.doEmit(self.ResetButton)

  def doStop(self):
    """Emit a Stop button click under program control.
    Can be done from a subthread."""

    # Ignore the doStop for this RunControl GUI
    return
    self.doEmit(self.StopButton)

  def doStopRun(self):
    """Depricated version of doStop()."""
    self.doStop()

  def doRun(self):
    """Emit a Run button click under program control.
    Can be done from a subthread."""
    self.doEmit(self.RunButton)

  def doPause(self):
    """Emit a Pause button click under program control.
    Can be done from a subthread."""
    self.doEmit(self.PauseButton)

  def doEmit(self, obj, signal = SIGNAL("clicked()"), args = ()):
    """Emit a signal, possibly from a subthread.
    By default the signal is 'clicked()' with no arguments."""
    if self.isGUIthread():
      obj.emit(signal, args)
    else:
      self.execGUImethodNR(obj.emit, signal, args)

  def normalCursor(self):
    self.execGUImethodNR(self.setCursor, QCursor(QWidget.ArrowCursor))

  def waitCursor(self):
    self.execGUImethodNR(self.setCursor, QCursor(QWidget.WaitCursor))

  def getHardwareVersions(self, lat=None):
    if self.__hwVersions is None:
      self.__hwVersions = Gversions.getHardwareVersions(lat)
    return self.__hwVersions

  def clearHardwareVersionsCache(self):
    self.__hwVersions = None

  def getFSM(self):
    return self.__fsm

  def setLAT(self, lat):
    self.__lat = lat

  def initGUIbridges(self):
    self.__thread = threading.currentThread()
    inQueue  = Queue()
    outQueue = Queue()
    self.__qtBridge = QtThreadBridge("QtBridge", outQueue, inQueue)
    self.__qtBridge.start()
    self.__pyBridge = PyThreadBridge("PyBridge", inQueue, outQueue)

  def isGUIthread(self):
    return threading.currentThread() == self.__thread

  def customEvent(self, e):
    # This method overrides the QObject base class's
    data = e.data()
    qtBridge = data[-1]
    if e.type() == RunControl.GUI_CMD_INST:
      qtBridge.pushResponse(data[0](*data[1:-2], **data[-2]))
    elif e.type() == RunControl.GUI_CMD_FUNC:
      qtBridge.pushResponse(data[0](*data[1:-2], **data[-2]))
    elif e.type() == RunControl.GUI_CMD_FUNC_NR:
      data[0](*data[1:-2], **data[-2])

  def createGUI(self, obj, *args, **kwargs):
    """Method used for instantiating a GUI from a non-GUI subthread"""
    self.__pyBridge.pushEvent((RunControl.GUI_CMD_INST, self, (obj,)+args+(kwargs,)))
    return self.__pyBridge.pullResponse()

  def execGUImethodNR(self, func, *args, **kwargs):
    """Method used for executing a GUI function from a non-GUI thread.
    Use this method when no (useful) response is expected or
    when waiting for one could cause a deadlock.  Any response from the
    function is lost."""
    if self.inShutdown:  return # Don't try to update the GUI during shutdown
    self.__pyBridge.pushEvent((RunControl.GUI_CMD_FUNC_NR, self, (func,)+args+(kwargs,)))

  def execGUImethod(self, func, *args, **kwargs):
    """Method used for executing a GUI function from a non-GUI thread.
    Use this method when a response is expected from the function and
    when it is appropriate to wait for it (no deadlock arises)"""
    self.__pyBridge.pushEvent((RunControl.GUI_CMD_FUNC, self, (func,)+args+(kwargs,)))
    return self.__pyBridge.pullResponse()

---