rcUtil.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 script engine related utility methods"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2005/09/22 00:29:31 $"
__version__  = "$Revision: 1.8 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import imp
import os
import sys
import logging as log
import string
from   types import ModuleType
from   FSM import FSM

class Reloader:
  """!\brief Reloader class.

  """
  DONT_RELOAD_LIST = ['scipy', 'weave', 'qwt', 'xml', 'pyexpat', 'win32',
                      'ROOT', 'libPyROOT']

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

    """
    self.appinit = {}

  def getNewModules(self, keepem):
    """!\brief Retrieve the new modules imported during the loading of the test.

    \param keepem List of modules which should be excluded from the reloading.
    """
    modules = {}
    for i, m in sys.modules.items():
      if (i not in keepem) and \
          (type(m) == ModuleType):
          modules[i] = m
    return modules

  def clearAppModules(self, dontReloadList, showUnloadedModules):
    """!\brief Unload modules that were loaded during the last test run.

    \param dontReloadList      List of module names which should not be unloaded
    \param showUnloadedModules Flag that indicates whether a debug log should
                               be printed for each module that gets unloaded
    """
    if self.appinit == {}:
      appfinish = {}
    else:
      appfinish = self.getNewModules(self.appinit)
    for i in self.filterModules(appfinish, dontReloadList):
      if i in sys.modules:
        if showUnloadedModules:
          log.debug("Unloading module %s %s" % (i, sys.modules[i].__file__))
        del sys.modules[i]
    self.appinit = sys.modules.copy()

  def filterModules(self, modules, dontReloadList):
    """!\brief Retrieve the list of modules that should be
              unloaded.

    \param modules        List of modules to be unloaded before filtering
    \param dontReloadList List of module names which should not be unloaded
    """
    dontReload = dontReloadList + Reloader.DONT_RELOAD_LIST
    mods = []
    for (moduleName, module) in modules.items():
      for modulePrefix in dontReload:
        if moduleName.startswith(modulePrefix):
          break
        if '__file__' not in dir(module):
          break
        if os.path.splitext(module.__file__)[1].lower() in ('.pyd','.dll'):
          break
        if os.path.normpath(os.path.normcase(module.__file__)).startswith(os.path.normpath(os.path.normcase(sys.prefix))):
          break
      else:
        mods.append(moduleName)
    return mods

reloadModules = Reloader()

def importModule(appName, reload=1, dontReloadList=[], showUnloadedModules=0):
  """!\brief Import a script engine application or suite.

  \param appName        Name of the module or pathname of the python script
  \param reload         1 = Reload all modules that have been loaded since
                            the Script Engine started (default)
                        0 = Do not reload modules (used if a suite is being loaded)
  \param dontReloadList Optional parameter which specifies the additional list
                        of module prefixes that should not be reloaded. If this
                        parameter is missing then the default list
                        (Reloader.DONT_RELOAD_LIST) is used, if it is specified
                        then it gets appended to the default list.

  \return The name of the module and the resolved pathname
  """
  # First check if a module name is specified, if so try to resolve its source.
  (appPath, appFile) = os.path.split(appName)
  (appBase, appExt)  = os.path.splitext(appFile)
  if appExt == '':
    try:
      if appPath == '':
        (f, path, desc) = imp.find_module(appBase)
      else:
        (f, path, desc) = imp.find_module(appBase, [appPath])
      (appPath, appFile) = os.path.split(path)
      (appBase, appExt)  = os.path.splitext(appFile)
    except ImportError, e:
      raise e

  _suffixes = {}
  for ext, mode, typ in imp.get_suffixes():
    _suffixes[ext] = (ext, mode, typ)
  _infoMap =  {
                '.py' : ('.py','r',1),
                '.pyc': ('.pyc','rb',2),
                '.pyo': ('.pyo','rb',2)
              }


  # Temporarily change the directory in case the application
  # needs to load additional modules from the same directory.
  curDir = os.getcwd()
  if appPath != '': os.chdir(appPath)

  # Handle relative paths, by resolving the path again after current directory is changed.
  appPath = os.getcwd()
  append = False
  if appPath not in sys.path:
    sys.path.append(appPath)
    append = True
  appName = os.path.join(appPath, appFile)

  pycFile = os.path.join(appPath, appBase + '.pyc')
  pyoFile = os.path.join(appPath, appBase + '.pyo')
  if appExt == '.py':
    if os.path.exists(pyoFile) and os.path.getmtime(pyoFile) >= os.path.getmtime(appName):
        filename = pyoFile
        appExt = '.pyo'
    elif _suffixes.has_key('.pyo'):
        filename = appName
    elif os.path.exists(pycFile) and os.path.getmtime(pycFile) >= os.path.getmtime(appName):
      filename = pycFile
      appExt = '.pyc'
    else:
      filename = appName
  elif appExt == '.pyc':
    if os.path.exists(pyoFile) and os.path.getmtime(pyoFile) >= os.path.getmtime(appName):
      filename = pyoFile
      appExt = '.pyo'
    else:
      filename = appName
  elif appExt == '.pyo':
    filename = appName
  else:
    msg = 'Invalid module extension: %s' % appName
    raise RuntimeError, msg
  info = _infoMap[appExt]
  f = file(filename, info[1])

  try:
    # Clear the modules that was imported during the loading and
    # execution of the previous script.
    if reload: reloadModules.clearAppModules(dontReloadList, showUnloadedModules)
    module = imp.load_module(appBase, f, filename, info)
  finally:
    f.close()
    if append:
      sys.path.remove(appPath)
    if os.path.exists(curDir):
      os.chdir(curDir)
  return (module, filename)

def getMainClass(module):
  """!\brief Retrieve the main class of an application or suite.

  Find out if the class inherits from FSM otherwise it is not the main class.
  If multiple main classes exist in one module then the one farthest away
  from FSM in the inheritance chain is used.

  \param module Application or suite module

  \return Main class or None
  """
  candidates = {}
  for objStr in dir(module):
    obj = getattr(module, objStr)
    if '__class__' in dir(obj) and getattr(obj,'__mro__',None) is not None:
      if FSM in obj.__mro__ and list(obj.__mro__).index(FSM) >= 2:
        candidates[obj] = list(obj.__mro__).index(FSM)
  if len(candidates) > 0:
    mainClass = None
    index     = 0
    for (obj, fsmIndex) in candidates.items():
      # We want the class that is farthest away from FSM in the
      # inheritence chain
      if fsmIndex > index:
        mainClass = obj
        index     = fsmIndex
    return mainClass

def scriptRun(app):
  """!\brief Run the test script or suite.

  \return Status of the last transition executed
  """
  for transition in app.getRunSequence():
    status = app.process(transition)
    if status is not None:
      return status

def scriptLoad(script, common, reload=1, *args, **kwargs):
  """!\brief Load the script.

  \param common ScriptEngineCommon instance
  \param reload Whether the reloading should be applied to the script.
                If reload=1, preference value is used, otherwise
                reloading is disabled
  \param args   Positional arguments
  \param kwargs Keyword arguments
  """
  if common.options().noreload is not None:
    dontReloadList = common.getDBN()["_dontReload"]
  else:
    dontReloadList = []
  prefs = common.preferences()
  if prefs['dontreload'].strip() != "":
    dontReloadPrefs = map(string.strip, prefs['dontreload'].split(','))
  else:
    dontReloadPrefs = []
  dontReloadList += dontReloadPrefs

  # Unless it is overridden by setting reload=0, use the preferences value
  if reload == 1:
    reload = not prefs["disablereload"]
  (module, filename) = importModule(appName=script,
                                    reload=reload,
                                    dontReloadList=dontReloadList,
                                    showUnloadedModules=prefs["showunloaded"] )

  appClass = getMainClass(module)

  if appClass is None:
    raise ImportError, "Application's base class does not inherit from FSM"
  else:
    return (module, filename, appClass(common, *args, **kwargs))

---