RunControlCommon.py

#!/usr/local/bin/python
#
#                               Copyright 2003
#                                     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__     = "2/5/2003"
__version__  = "$Revision: 2.46 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC


import sys
import os
import time
import types
import atexit
import socket
import logging as log
import logging.handlers
from rcLoginImpl          import rcLoginImpl
from rcSecurityMan        import rcSecurityMan
from rcPreferencesManager import rcPreferencesManager
from rcPreferencesGUIImpl import rcPreferencesGUIImpl

from LATTE.client.gOptions import Options
from LATTE.client.gCmdCli import CmdCli
from LATTE.client.gEvtCli import EvtCli
from LATTE.database.gLAT import GLAT
from LATTE.database.gXBR import GXBRD
from LATTE.database.gOCS import GOCS
from LATTE.logger.MSGLogGUIImpl import MSGLogGUIImpl
from LATTE.database.gVersions import Gversions


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 Initialize the dictionary.

    """
    dict.__init__(self)


class RunControlSocketHandler(logging.handlers.SocketHandler):
  def __init__(self, *args):
    apply(logging.handlers.SocketHandler.__init__, (self,) + args)

  def handleError(self, 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):
  def __init__(self, common):
    logging.Handler.__init__(self)
    self.__common = common

  def emit(self, record):
    self.__common.incrementErrorLogCount()

class RunControlFileHandler(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):
    log.FileHandler.__init__(self, filename, mode)

  def emit(self, 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 RunControlCommon(object):
  """Common class for providing a run control helper functions
  """
  def __init__(self):
    self.MSGLogger = None
    self.__startGMT = time.gmtime()
    self.__options  = Options(['config', 'server'],
                              ['appdir','cmddebug','evtdebug','fswmsglevel',
                               'noreload','schema','securedir','app',
                               'ocsport'],
                              ['initforce','noerrfile','norcoverride',
                               'ocsverbose','oesforce',
                               'playback','paramverify','noplumbing'])
    if len(sys.argv) > 1 and sys.argv[1] == '--help':
      self.__options.usage()
      print self.__usage()
      sys.exit(0)
    self.__lat = None
    self.__xbrd = None
    self.__dds = None
    self.__server = None
    try:
      self.__options.parse()
    except Exception, msg:
      self.__options.usage(self.__usage())
      raise Exception, msg

    if self.__options.ocsport is not None:
      self.__cmdCli = CmdCli(port=int(self.__options.ocsport))
      self.__evtCli = EvtCli(port=int(self.__options.ocsport))
    else:
      self.__cmdCli = CmdCli()
      self.__evtCli = EvtCli()
    self.__ocs = GOCS(self.__cmdCli)
    self.__securityMan = None
    self.__dbn = GDBN()
    self.__prefMan = None
    self.__prefGUI = None
    self.__errLogCnt = 0
    self.__hwVersions = None

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

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

  def initialize(self, startup=False):
    self.__prefMan = rcPreferencesManager(self.__options.config)
    if (self.__prefMan.loadConfig()):
      if self.__options.cmddebug is not None:
        self.__cmdCli.setDebug(int(self.__options.cmddebug))

      if self.__options.evtdebug is not None:
        self.__evtCli.setDebug(int(self.__options.evtdebug))

      self.startLogger(startup)

      if self.__options.securedir is not None:
        self.__securityMan = rcSecurityMan(os.path.abspath(self.__options.securedir),
                                           self.__prefMan.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())
    else:
      raise RuntimeError, "Can not find configuration file: %s" % self.__options.config

  def __usage(self):
    return """

Detailed explanation:

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

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 client debug mode (defaults to 0).
   If this option is specified then all register accesses from the
   command client is logged to the logger.
--evtdebug Specify event client debug mode (defaults to 0)
   The following debug modes are available and can be added together
   for combinations:
     0: No Debug
     1: Debug All
     2: Event Dump
     4: Warnings
     8: Parser Output
    16: Error Output
--fswmsglevel Specify the FSW message level for the OCS manager task.
--initforce Force command-response and event fabrics initialization on the SBC.
--noerrfile Disable error archive file output.
--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.
--ocsverbose Enable fabrics initialization messages on the SBC.
--noplumbing Do not automatically plumb the LAT upon connection.
--ocsport Define the port used to connect to OCS
--oesforce Force our OES socket to be the default event server for the SBC.
--paramverify Force the parameter verifier to come up even if running in non-secure mode
--playback Indicate that Run Control should command the
   event server to play back the next event from its file. Since
   this is done using the GLT's self trigger command, the state of
   the internal trigger enable bit deterimines whether the
   application or Run Control will issue the self trigger command.
   No events will be delivered if the application has the internal
   trigger enabled, but doesn't issue CMD_SELF_TRIGGERs.
--schema Specify the schema file to load.
--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 RunControl is started in secure mode.
  """




  def connect(self, force=False):
    self.__cmdCli.connect(self.__options.server)
    self.__evtCli.connect(self.__options.server, force)
    self.__evtCli.purge()

  def disconnect(self):
    self.__cmdCli.disconnect()
    self.__evtCli.disconnect()

  def readSchema(self, filename):
    self.__lat = GLAT(self.__cmdCli)
    self.__lat.readSchema(filename)
    # Do not load the schema again if the GXBRD node does not exist.
    # See LTE-325 for more info.
    if self.__lat.xbrdExists():
      self.__xbrd = GXBRD(self.__cmdCli)
      self.__xbrd = self.__xbrd.readSchema(filename)
    else:
      self.__xbrd = None
    self.__dbn['_LATSchema'] = self.__lat
    self.__dbn['_LATSchemaFile'] = filename
    self.__dbn['_XBRDSchema'] = self.__xbrd
    self.__dbn['_XBRDchemaFile'] = filename

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

  def EBFdistribution(self):
    if int(self.__prefMan.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.__prefMan.preferences()["server"].strip()
    if server != '':
      try:
        import LATTE.tools.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.__prefMan.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.__prefMan.preferences()["server"], dataType))
            self.__dds = None
      self.__server = self.__prefMan.preferences()["server"].strip()

  def setLoggingLevel(self, logLevel=None):
    if logLevel is None: logLevel = self.__prefMan.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__ == 'RunControlSocketHandler':
        hdlr.setLevel(eval("log."+logLevel))
      elif hdlr.__class__.__name__ == 'ErrorLogCounterHandler':
        hdlr.setLevel(eval("log.ERROR"))

  def startLogger(self, startup=True):
    # Start up the message logger
    log.basicConfig()
    loghost = self.__prefMan.preferences()["loghost"]
    logport = self.__prefMan.preferences()["logport"]
    local = socket.gethostname().lower() == loghost.lower() or socket.gethostbyname(loghost) == '127.0.0.1'
    if int(self.__prefMan.preferences()["lognbl"]) == 1:
      if local and startup:
        if self.MSGLogger is not None:
          return
        self.MSGLogger = MSGLogGUIImpl(logport)
        self.MSGLogger.startListenerThread()
      msgPath = self.__prefMan.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"
      self.__prefMan.preferences()["logfilename"] = fileName
      fmt = log.Formatter("%(asctime)s(UT) %(filename)s:%(lineno)d %(levelname)-5s - %(message)s")
      fmt.converter = time.gmtime
      self.fileHdlr = RunControlFileHandler(os.path.join(msgPath, fileName), "a")
      self.fileHdlr.setFormatter(fmt)
      log.getLogger("").addHandler(self.fileHdlr)
      self.sockHdlr = RunControlSocketHandler(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):
    fileHdlr.close()
    log.getLogger("").removeHandler(fileHdlr)

  def startRunLog(self, fileName):
    fileHdlr = RunControlFileHandler(fileName, "w")
    fmt = log.Formatter("%(asctime)s(UT) %(filename)s:%(lineno)d %(levelname)-5s - %(message)s")
    fmt.converter = time.gmtime
    fileHdlr.setFormatter(fmt)
    log.getLogger("").addHandler(fileHdlr)
    return fileHdlr

  def options(self):
    return self.__options

  def prefMan(self):
    return self.__prefMan

  def prefGUI(self):
    if self.__prefGUI is None:
      self.__prefGUI = rcPreferencesGUIImpl(self)
    return self.__prefGUI

  def getMSGLogger(self):
    return self.MSGLogger

  def getDDS(self):
    return self.__dds

  def getCmdCli(self):
    return self.__cmdCli

  def getEvtCli(self):
    return self.__evtCli

  def getLAT(self):
    return self.__lat

  def getXBRD(self):
    return self.__xbrd

  def getOCS(self):
    return self.__ocs

  def getDBN(self):
    return self.__dbn

  def getSecurityMan(self):
    return self.__securityMan

  def getQtApp(self):
    return self.__qApp

  def getLoginId(self):
    """Returns the login id for the last successful login
    """
    return self.__loginId

  def getErrorLogCount(self):
    return self.__errLogCnt

  def incrementErrorLogCount(self):
    self.__errLogCnt += 1

  def resetErrorLogCount(self):
    self.__errLogCnt = 0

  def showLogin(self, parent):
    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 getHardwareVersions(self, lat=None, xbrd=None):
    if self.__hwVersions is None:
      if lat is None: lat = self.getLAT()
      if xbrd is None: xbrd = self.getXBRD()
      self.__hwVersions = Gversions.getHardwareVersions(lat, xbrd)
    return self.__hwVersions

  def clearHardwareVersionsCache(self):
    self.__hwVersions = None

---