ScriptEngineCommon.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "GLAST LAT run control common class"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/04/26 21:46:21 $"
__version__  = "$Revision: 1.53 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC


import sys
import os
import time
import types
import atexit
import socket
import logging as log
import logging.handlers
from   ConfigParser import ConfigParser, NoOptionError
import threading

from rcLoginImpl          import rcLoginImpl
from rcSecurityMan        import rcSecurityMan
from rcPreferencesManager import rcPreferencesManager
from rcPreferencesGUIImpl import rcPreferencesGUIImpl

from LICOS.scriptEngine.ScriptEngineConnector import ScriptEngineConnector
from LICOS.lib.currValTable.ScriptClient      import ScriptClient
from LICOS.lib.cmdTlmDb.LCATtlmDb             import LCATtlmDb
from LICOS.lib.cmdTlmDb.LCATcmdDb             import LCATcmdDb
from LICOS.util.gOptions                      import Options
from LICOS.tools.logger.MSGLogGUIImpl         import MSGLogGUIImpl
from LICOS.util.gVersions                     import Gversions
from LICOS.scriptEngine.HwCfgSelectorImpl     import HwCfgSelectorImpl
from LICOS.lib.LATconstants                   import *

from ISOC.TlmUtils.TlmRdbInterface import TlmRdbDb
import VSC


class GDBN(dict):
  """!\brief Database node record.

     The database node contains session level variables in addition
     to preferences and entries used for diagnostics purposes.
  """
  def __init__(self):
    """!\brief GDBN constructor.

    Initialize the dictionary.

    """
    dict.__init__(self)


class ScriptEngineSocketHandler(logging.handlers.SocketHandler):
  """!\brief Socket handler for logging.

  """
  def __init__(self, *args):
    """!\brief ScriptEngineSocketHandler constructor.

    \param args Positional arguments
    """
    apply(logging.handlers.SocketHandler.__init__, (self,) + args)

  def handleError(self, record):
    """!\brief Handle error.

    \param record Log record
    """
    if self.closeOnError and self.sock:
      self.sock.shutdown(2)
      self.sock.close()
      self.sock = None        #try to reconnect next time
    else:
      raise IOError, sys.exc_info()[1]

class ErrorLogCounterHandler(logging.Handler):
  """!\brief Log handler to check if any ERROR logs are produced during the run.

  """
  def __init__(self, common):
    """!\brief ErrorLogCounterHandler constructor.

    """
    logging.Handler.__init__(self)
    self.__common = common

  def emit(self, record):
    """!\brief Log handler callback.

    Increment the error log count.

    \param record Log record
    """
    self.__common.incrementErrorLogCount()

class ScriptEngineFileHandler(log.FileHandler):
  """!\brief FileHandler class for handling multiple line log entries

  If a log entry contains multiple lines, such as the case for
  tracebacks or exceptions a begin and end delimiter is added
  to the log entry so that it can be parsed by the MessageLogger
  """
  def __init__(self, filename, mode):
    """!\brief ScriptEngineFileHandler constructor.

    """
    log.FileHandler.__init__(self, filename, mode)

  def emit(self, record):
    """!\brief Log handler callback.

    Format the log message. If it is a multiline message
    (like in exceptions), delimit the beginning and ending
    of the message.

    \param record Log record
    """
    try:
      msg = self.format(record)
      (msg1, msg2) = msg.split(' - ',1)
      if msg2.find('\n') > 0:
        msg = msg1 + " - <//" + msg2+"//>"
      if not hasattr(types, "UnicodeType"): #if no unicode support...
        self.stream.write("%s\n" % msg)
      else:
        try:
          self.stream.write("%s\n" % msg)
        except UnicodeError:
          self.stream.write("%s\n" % msg.encode("UTF-8"))
      self.flush()
    except:
      self.handleError(record)

class ScriptEngineCommon(object):
  """!\brief Common class for providing a run control helper functions.

  """
  def __init__(self):
    """!\brief ScriptEngineCommon constructor.

    """
    self.MSGLogger = None
    self.__startGMT = time.gmtime()
    self.__options  = Options(['config', 'server', 'vscConfig'],
                              ['noreload', 'securedir',
                               'app', 'appdir',
                               'cvtHost', 'cvtPort', 'scriptOpts',
                               'diagHost', 'telemHost'],
                              ['cmdDebug', 'endRunDlg', 'norcoverride',
                               'paramverify'])
    if len(sys.argv) > 1 and sys.argv[1] == '--help':
      self.__options.usage()
      print self.__usage()
      sys.exit(0)
    self.__dds = None
    self.__server = None
    try:
      self.__options.parse()
    except Exception, msg:
      self.__options.usage(self.__usage())
      raise Exception, msg

    self.__evtCli = None
    self.__securityMan = None
    self.__dbn = GDBN()
    self.__dbn['_common'] = self
    self.__prefMan = None
    self.__prefGUI = None
    self.__errLogCnt = 0
    self.__hwVersions = None
    self.__gui = None
    self.__diagHandler = None
    self.__tlmDb = None
    self.__lcat = None
    self.__lcatTlm = None

    try:
      import qt
      self.__qApp = qt.QApplication([])
      self.__qApp.addLibraryPath(os.path.join(ONLINE_ROOT, 'LICOS/ext/plugins'))
    except ImportError:
      self.__qApp = None

    # Arrange for logging to be properly shutdown at program exit
    atexit.register(log.shutdown)

  def connectVSC(self):
    """!\brief Connect to the Script Engine Proxy.

    """
    configFile = os.path.abspath(self.__options.vscConfig)
    config = ConfigParser()
    config.readfp(file(configFile))

    try:
      archive_path = config.get('paths','archive_path')
      granularity  = config.getint('ccsds_archivers',
                                    'granularity')
      if len(archive_path) != 0:
        from LICOS.tools.proxy.VscArchivers import VscArchiver
        archiver = VscArchiver("CMD", archive_path, granularity)
      else:
        print "Archiving disabled due to null archive_path or ingest_path"
        archiver = None
    except NoOptionError, e:
      print "Archiving disabled: ", e
      archiver = None

    ## Read hardware configuration options
    #hwConfig = {}
    #try:
    #  hwConfig['siuSelect'] = config.get('lat','siuSelect')
    #  hwConfig['daqSelect'] = config.get('lat','daqSelect')
    #  hwConfig['siuIdPhysical'] = config.get('lat','siuIdPhysical')
    #  hwConfig['siuIdLogical'] = config.get('lat','siuIdLogical')
    #  hwConfig['pduId'] = config.get('lat','pduId')
    #  hwConfig['primaryFeed'] = config.get('lat','primaryFeed')
    #  hwConfig['primaryGasu'] = config.get('lat','primaryGasu')
    #  hwConfig['firstEpuId'] = config.get('lat','firstEpuId')
    #  hwConfig['secondEpuId'] = config.get('lat','secondEpuId')
    #  hwConfig['acdSupply'] = config.get('lat','acdSupply')
    #  hwConfig['hvbs'] = config.get('lat','hvbs')
    #except NoOptionError, e:
    #  log.warn("One or more hardware configuration options not found, some scripts may fail.")
    #  log.exception(e)
    #self.__prefMan.setPref('hwConfig', hwConfig)

    diagHost = self.__options.diagHost
    if diagHost is None: diagHost = 'localhost'
    telemHost = self.__options.telemHost
    if telemHost is None: telemHost = 'localhost'
    portBase = config.getint('vsc', 'proxyPortBase')
    vsc = ScriptEngineConnector( vscHost=self.__options.server,
                                 diagHost=diagHost,
                                 telemHost=telemHost,
                                 archiver=archiver,
                                 cmdDebug=self.__options.cmdDebug,
                                 portBase = portBase)
    self.__lcatTlm = LCATtlmDb()
    vsc.setTlmDb(self.__lcatTlm)
    vsc.initCmdCountMon()
    vsc.start()
    vsc.m7default()
    #vsc.monitor(VSC.VscProxy.Primary)   # {Primary, Redundant, None}
    self.__vsc = vsc
    self.__dbn['_vsc'] = vsc
    self.__lcat = LCATcmdDb(vsc)
    self.__lcat.LIM.startStateMonitor()

    # TODO: Move this to a plugin class in the future
    self.addLatWatchItems()

  def getLCATcmd(self):
    """!\brief Retrieve the LCAT command database wrapper instance.

    \return LCATcmdDb instance
    """
    return self.__lcat

  def getLCATtlm(self):
    """!\brief Retrieve the LCAT telemetry database wrapper instance.

    \return LCATtlmDb instance
    """
    return self.__lcatTlm

  def addLatWatchItems(self):
    """!\brief Add LAT related watch items to the status panel.

    """
    statMon = self.__gui.statusMonitor()
    statMon.addWatchItem('LAT Configuration', self.getLatConfigId)
    lim = self.getLCATcmd().LIM
    statMon.addWatchItem('LIM Operating Mode', lim.getOperatingModeStr,
                         isStale=lim.isLimStateStale)
    statMon.addWatchItem('LIM Action', lim.getActionStr,
                         isStale=lim.isLimStateStale)
    statMon.addWatchItem('LIM Status', lim.getStatusStr,
                         isStale=lim.isLimStateStale)
    self.__gui.statusMonitor().saveWatch()


  def connectCVT(self):
    """!\brief Connect to the current value table.

    """
    try:
      self.cvt = ScriptClient(self.__options.cvtHost, int(self.__options.cvtPort))
    except:
      log.info("Connection to CVT failed.  User scripts that call the CVT may fail")
      self.cvt = None
      pass

  def populateTlmDb(self):
    try:
      import psycopg
    except ImportError:
      log.warn("Unable to import the Postgres Python package, EGU conversions will not be available")
      return
    try:
      #DSN = "user=panetta dbname=panetta host=gitow1 password=panetta"
      configFile = self.__options.vscConfig
      config = ConfigParser()
      config.read(configFile)
      DSN = config.get('postgres', 'dsn')
      db = psycopg.connect( DSN )
      dbc = db.cursor()
      self.__tlmDb = TlmRdbDb(dbc)
      src = config.get('tlmdb', 'source')
      bld = config.get('tlmdb', 'build')
      self.__tlmDb.populate(source=src, build=bld)
    except Exception, e:
      log.exception("Unable to populate the telemetry database")
      self.__tlmDb = None

  def initialize(self, startup=False):
    """!\brief Initialization.

    \param startup Are we initializing for the first time?
    """
    self.__prefMan = rcPreferencesManager(self.__options.config)
    if (self.__prefMan.loadConfig()):

      self.startLogger(startup)

      #if self.__options.schema is not None:
      #  try:
      #    self.readSchema(os.path.abspath(self.__options.schema))
      #  except Exception, e:
      #    log.exception("Exception in readSchema:")
      #    raise e

      if self.__options.securedir is not None:
        self.__securityMan = rcSecurityMan(os.path.abspath(self.__options.securedir),
                                           self.preferences()["users"])
        self.__securityMan.readPermissions()
        self.__dbn['_securityMan'] = self.__securityMan
      if self.__options.noreload is not None:
        import string
        self.__dbn["_dontReload"] = map(string.strip, file(self.__options.noreload).readlines())
      if self.__options.scriptOpts is not None:
        scrOptsFile = os.path.abspath(self.__options.scriptOpts)
        self.__scriptOpts = self.readScriptOpts(scrOptsFile)
      else:
        self.__scriptOpts = {}

    else:
      raise RuntimeError, "Can not find configuration file: %s" % self.__options.config

  def readScriptOpts(self, scrOptsFile):
    """!\brief Read the script options file.

    The script options file is used to debug a script without
    issuing a LICOS release. It should not be used in 'for credit'
    runs since it may change the behavior of the script.

    The script options file is a configuration file parsable by
    ConfigParser. Each section contains the script name. Under
    each section the options for that script and their values
    are listed.

    The options used for a given script are recorded in the run
    report.

    \param scrOptsFile File containing the script options

    \return Dictionary containing the script options
    """
    config = ConfigParser()
    config.readfp(file(scrOptsFile))
    scriptOpts = {}
    for section in config.sections():
      scriptOpts[section] = {}
      for option in config.options(section):
        scriptOpts[section][option] = config.get(section, option)
    return scriptOpts

  def getScriptOpts(self, scriptName):
    """!\brief Retrieve the options for script \a scriptName.

    \param scriptName Name of the script

    \return Dictionary of options for the script or None.
    """
    if scriptName in self.__scriptOpts:
      return self.__scriptOpts[scriptName]
    else:
      return {}

  def __usage(self):
    """!\brief Usage.

    """
    return """

Detailed explanation:

Mandatory options:
--config to specify the run control configuration file to use
--server to specify the hostname or the IP address of the teststand crate
   to connect to.
--vscConfig to specify the configuration of the VSC and related quantities

Optional options:
--app Specify the standalone application or suite to run.
   Typically used by test or suite runners.
--appdir Specify the application directory
--cmdDebug Specify command debugging.
--cvtHost Current value table host.
--cvtPort Current value table port.
--diagHost Diagnostic proxy host. If omitted, defaults to localhost.
--endRunDlg Force the end run dialog to come up even in non-secure mode.
--norcoverride Prevents the run conditions to be overridden with NOT-DEFINED.
--noreload Specify a file that contains prefixes of modules
   which should not be reloaded when a user script is selected.
   This list gets appended to the default list which currently contains
   the following prefixes 'scipy', 'weave', 'qwt', 'xml', 'pyexpat', 'win32'.
   The file should contain one prefix per line.
--paramverify Force the parameter verifier to come up even if running in non-secure mode
--scriptOpts Specify a configuration file containing script specific options.
   The script name is specified as a section and all options can be specified
   under that section.
--securedir The full path to the secure directory where the password file
   ("passwords") and the user permissions file ("security.cfg") is stored.
   If this switch is specified then ScriptEngine is started in secure mode.
--telemHost Telemetry proxy host. If omitted, defaults to localhost.
  """


  def connect(self):
    """!\brief Connect to the servers.

    """
    #self.__cmdCli.connect(self.__options.server)
    #self.__evtCli.connect(self.__options.server, force)
    #self.__evtCli.purge()
    self.connectCVT()
    self.populateTlmDb()
    self.connectVSC()

  def disconnect(self):
    """!\brief Disconnect from the servers.

    """
    # TODO: Do we need to send any commands here to disconnect from the VSC?
    pass

  def elogWebsite(self):
    """!\brief Launch the web browser and point it to the E-Logbook site.

    """
    import webbrowser
    webbrowser.open(url=self.preferences()["elogurl"], new=1)

  def EBFdistribution(self):
    """!\brief Initialize the data distribution server.

    """
    if int(self.preferences()["servernbl"]) == 0:
      if self.__dds is not None:
        self.__dds.disconnect()
        log.info("Disconnected from the data distribution server since it was disabled in preferences.")
        self.__dds = None
      return
    dataType   = 'LAT_EBFdata'
    server     = self.preferences()["server"].strip()
    if server != '':
      try:
        import LICOS.core.distributor.DataDistributor as DD
      except:
        log.error("Can't find DataDistributor module, is it in PYTHONPATH?")
      else:
        if self.__server is None:
          self.__dds = DD.DataDistributorServer(dataType)
          try:
            self.__dds.connect(server)
            log.info("Connected to the data distribution server at %s." % server)
            #atexit.register(self.__dds.disconnect)  # Already done somewhere?
          except:
            log.warn("Unable to connect to data distribution server %s: serving of %s disabled" % (self.preferences()["server"], dataType))
            self.__dds = None
        elif server != self.__server:
          if self.__dds is not None:
            self.__dds.disconnect()
            log.info("Disconnected from the data distribution server.")
          self.__dds = DD.DataDistributorServer(dataType)
          try:
            self.__dds.connect(server)
            log.info("Reconnected to the data distribution server since the server changed in preferences.")
            #atexit.register(self.__dds.disconnect)  # Already done somewhere?
          except:
            log.warn("Unable to connect to data distribution server %s: serving of %s disabled" % (self.preferences()["server"], dataType))
            self.__dds = None
      self.__server = self.preferences()["server"].strip()

  def setLoggingLevel(self, logLevel=None):
    """!\brief Set the logging level.

    \param logLevel Log level.
                    Can be one of "DEBUG","INFO","WARN","ERROR","CRITICAL"
    """
    if logLevel is None: logLevel = self.preferences()["loglevel"]
    # Set the log levels at the handler level so that
    # file based handlers can still record DEBUG logs.
    log.getLogger("").setLevel(0)
    # First handler is always the default stdout handler
    log.getLogger("").handlers[0].setLevel(eval("log."+logLevel))
    for hdlr in log.getLogger("").handlers[1:]:
      if hdlr.__class__.__name__ == 'ScriptEngineSocketHandler':
        hdlr.setLevel(eval("log."+logLevel))
      elif hdlr.__class__.__name__ == 'ErrorLogCounterHandler':
        hdlr.setLevel(eval("log.ERROR"))

  def startLogger(self, startup=True):
    """!\brief Start the logger.

    \param startup Are we calling startLogger from startup?
    """
    # Start up the message logger
    log.basicConfig()
    loghost = self.preferences()["loghost"]
    logport = self.preferences()["logport"]
    local = socket.gethostname().lower() == loghost.lower() or socket.gethostbyname(loghost) == '127.0.0.1'
    if int(self.preferences()["lognbl"]) == 1:
      if local and startup:
        if self.MSGLogger is not None:
          return
        self.MSGLogger = MSGLogGUIImpl(logport)
        self.MSGLogger.startListenerThread()
      msgPath = self.preferences()["logdir"]
      # Note that if the file already exists, it will be appended to
      ts   = time.strftime('%y%m%d%H%M%S', self.__startGMT)
      fileName = "msg" + ts + ".log"
      # Hack until the log handler goes in its own class -ST # revisit
      self.preferences()["logfilename"] = fileName
      fmt = log.Formatter("%(asctime)s %(filename)s:%(lineno)d %(levelname)-5s - %(message)s")
      self.fileHdlr = ScriptEngineFileHandler(os.path.join(msgPath, fileName), "a")
      self.fileHdlr.setFormatter(fmt)
      log.getLogger("").addHandler(self.fileHdlr)
      self.sockHdlr = ScriptEngineSocketHandler(loghost, logport)
      self.sockHdlr.setFormatter(fmt)
      log.getLogger("").addHandler(self.sockHdlr)
      self.errLogCounter = ErrorLogCounterHandler(self)
      log.getLogger("").addHandler(self.errLogCounter)
      self.setLoggingLevel()
      try:
        log.info('Trying to connect to the message logger')
      except:
        log.getLogger("").removeHandler(self.sockHdlr)
        log.exception("Can't connect to the message logger, disabling logging to socket")
      else:
        log.info('Successfully connected to the message logger')
    elif self.MSGLogger is not None:
      log.info('Disconnecting from the message logger')
      if local:
        self.MSGLogger.close()
        self.MSGLogger = None
      log.getLogger("").removeHandler(self.errLogCounter)
      log.getLogger("").removeHandler(self.sockHdlr)
      log.getLogger("").removeHandler(self.fileHdlr)
      log.shutdown()
    else:
      # Make sure error log counter handler is added
      # even when logs are disabled
      self.errLogCounter = ErrorLogCounterHandler(self)
      log.getLogger("").addHandler(self.errLogCounter)
      self.setLoggingLevel()


  def stopRunLog(self, fileHdlr):
    """!\brief Stop the file log.

    \brief fileHdlr Log file handler.
    """
    # Acquire the I/O thread lock so that we don't accept any more logs
    # for this handler while the log is being closed.
    fileHdlr.acquire()
    log.getLogger("").removeHandler(fileHdlr)
    fileHdlr.release()
    fileHdlr.close()

  def startRunLog(self, fileName):
    """!\brief Start the file log.

    \brief fileName File name for the log file.
    """
    fileHdlr = ScriptEngineFileHandler(fileName, "w")
    fmt = log.Formatter("%(asctime)s %(filename)s:%(lineno)d %(levelname)-5s - %(message)s")
    fileHdlr.setFormatter(fmt)
    log.getLogger("").addHandler(fileHdlr)
    return fileHdlr

  def startLcmLog(self, filename):
    self.__lcmFile = file(filename, "w")
    self.__vsc.getDiagHandler().register(self.__lcatTlm.getApidsFromNames(['LCMMSGOUTC']), self.__processMsgOut)

    # Lock object used to coordinate the closing of the LCM log
    # with the callback __processMsgOut that handles the writing
    self.__lcmLock = threading.Lock()

  def stopLcmLog(self):
    self.__vsc.getDiagHandler().unregister(self.__lcatTlm.getApidsFromNames(['LCMMSGOUTC']),
                                         self.__processMsgOut)
    self.__lcmLock.acquire()
    self.__lcmFile.close()
    self.__lcmLock.release()

  def __processMsgOut(self, telem):
    self.__lcmLock.acquire()
    if not self.__lcmFile.closed:
      pkt = self.__lcatTlm.decodeTelemetry(telem)
      msg = self.__lcatTlm.msgOutToText(pkt)
      log.debug(msg)
      self.__lcmFile.write(msg + '\n')
      self.__lcmFile.flush()
    self.__lcmLock.release()

  def options(self):
    """!\brief Retrieve the command line options.

    \return Command line options.
    """
    return self.__options

  def prefMan(self):
    """!\brief Retrieve the preferences manager.

    \return rcPreferencesManager instance
    """
    return self.__prefMan

  def preferences(self):
    """!\brief Retrieve the preferences.

    \return Preferences instance
    """
    return self.__prefMan.preferences()

  def prefGUI(self):
    """!\brief Retrieve the preferences GUI.

    \return rcPreferencesGUIImpl instance
    """
    if self.__prefGUI is None:
      self.__prefGUI = rcPreferencesGUIImpl(self)
    return self.__prefGUI

  def getMSGLogger(self):
    """!\brief Retrieve the message logger GUI.

    \return MSGLogGUIImpl instance
    """
    return self.MSGLogger

  def getDDS(self):
    """!\brief Retrieve the data distributor.

    \return DataDistributorServer instance
    """
    return self.__dds

  def getCmdCli(self):
    """!\brief Retrieve the Script Engine proxy.

    \return seProxy instance
    """
    # TODO: Should the VSC connection come from the script?
    #return self.__cmdCli
    return self.__vsc

  def getTlmDb(self):
    """!\brief Retrieve the telemetry database object.

    This object contains EGU conversions for LAT housekeeping telemetry.

    \return An ISOC.TlmUtils.TlmRdbInterface.TlmRdbDb instance
    """
    return self.__tlmDb

  def getDBN(self):
    """!\brief Retrieve the DBN node.

    \return GDBN instance.
    """
    return self.__dbn

  def getSecurityMan(self):
    """!\brief Retrieve the security manager.

    \return rcSecurityMan instance
    """
    return self.__securityMan

  def getQtApp(self):
    """!\brief Retrieve the Qt app.

    \return QApplication instance
    """
    return self.__qApp

  def setGUI(self, gui):
    """!\brief Set the GUI.

    \param gui The GUI widget
    """
    self.__gui = gui

  def getGUI(self):
    """!\brief Retrieve the GUI.

    \return The GUI widget
    """
    return self.__gui

  def getLoginId(self):
    """!\brief Returns the login id for the last successful login

    \return User's login id
    """
    return self.__loginId

  def getErrorLogCount(self):
    """!\brief Retrueve the error log count for the current run.

    \return Error log count
    """
    return self.__errLogCnt

  def incrementErrorLogCount(self):
    """!\brief Increment the error log count.

    """
    self.__errLogCnt += 1

  def resetErrorLogCount(self):
    """!\brief Reset the error log count.

    """
    self.__errLogCnt = 0

  def showLogin(self, parent):
    """!\brief Handle login.

    \param parent Parent GUI

    \return Authentication result, 0=Successful login,
                                  -1=Authentication failed,
                                  else password database is not accessible.
    """
    login = rcLoginImpl(parent=parent)
    status = login.exec_loop()
    if status == login.Accepted:
      loginId = str(login.txtLoginId.text()).strip()
      password = str(login.txtPassword.text()).strip()
      authResult = self.__securityMan.authenticateUser(loginId, password)
      if authResult == 0:
        self.__loginId = loginId
        log.info("User %s successfully logged in" % loginId)
        return 1
      elif authResult == -1:
        log.error("User authentication failed, loginId=%s" % loginId)
        return authResult
      else:
        log.error("Password database is not accessible.")
        return authResult
    else:
      return None

  def configureHardware(self):
    """!\brief Configure the hardware based on the user selection.

    \return Whether the user cancelled or confirmed the selection
    """
    hwCfgGUI = HwCfgSelectorImpl(self, self.getGUI())
    hwCfgGUI.setCaption("Hardware Configuration Selector")
    result = hwCfgGUI.exec_loop()
    if result:
      hwConfig = self.preferences()["hwConfig"]
      self.__vsc.siuSelect(getattr(self.__vsc, hwConfig['siuSelect']))
      self.__vsc.daqSelect(getattr(self.__vsc, hwConfig['daqSelect']))
      if hwConfig['primaryFeed'] == 1:
        self.__vsc.monitor(VSC.VscProxy.Primary)   # {Primary, Redundant, None}
      else:
        self.__vsc.monitor(VSC.VscProxy.Redundant)   # {Primary, Redundant, None}
    return result

  def getLatConfigId(self):
    if "hwConfig" in self.preferences():
      preset = self.preferences()["hwConfig"]["preset"]
      if preset == -1:
        return "NON STANDARD"
      else:
        return preset

  def getDiagHandler(self):
    """!\brief Retrieve the LAT/VSC diagnostic telemetry handler.

    \return seTelemetryHandler instance
    """
    return self.__vsc.getDiagHandler()

  def getTelemHandler(self):
    """!\brief Retrieve the LAT/VSC telemetry handler.

    \return seTelemetryHandler instance
    """
    return self.__vsc.getTelemHandler()

  def getPidsHandler(self):
    """!\brief Retrieve the pids telemetry handler.

    \return sePidsHandler instance
    """
    return self.__vsc.getPidsHandler()

---