rcPreferencesManager.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__ = "Script Engine Preferences manager GUI module"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/04/11 20:10:07 $"
__version__  = "$Revision: 1.9 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import                sys
import                os
import                types
import                re
import                string
import logging     as log
import                logging.handlers
from ConfigParser     import *
from rcUsers          import rcUser, rcUsers

class rcPreferencesManager(object):
  """!\brief Class for managing the preferences.

  """
  def __init__(self, configFile):
    """!\brief rcPreferencesManager constructor

    \param configFile Configuration file name
    """
    self.__prefs = Preferences()
    self.__configFile = configFile
    self.__pythonPath = sys.path
    self.__configFile = os.path.abspath(configFile)
    confParser = self.loadDefaults(os.getcwd())
    self.__defPrefs = self.parserToPrefs(confParser)

  def loadConfig(self):
    """!\brief Parse and load the configuration file

    \return 1
    """
    confParser = ConfigParser()
    if os.path.exists(self.__configFile):
      confParser.read(self.__configFile)
    else:
      return None

    self.parserToPrefs(confParser, self.__prefs)

    # Do not override the paths with default values anymore since the paths
    # may point to disconnected network drives.
    #
    #for dirname in Preferences.DIR_LIST:
    #  if not self.__prefs.has_key(dirname) or not os.path.isdir(self.__prefs[dirname]):
    #    self.__prefs[dirname] = self.__defPrefs[dirname]

    for choice in (Preferences.CHOICE_LIST +
                   Preferences.LOGGING_LIST +
                   Preferences.SYSTEM_LIST):
      if not self.__prefs.has_key(choice):
        self.__prefs[choice] = self.__defPrefs[choice]

    return 1

  def writeConfig(self):
    """!\brief Write the configuration back to the file.

    """
    confParser = self.prefsToParser()
    try:
      confParser.write(file(self.getConfigFile(), "w+"))
    except IOError, (errno, errdetail):
      log.error("*** rcPreferencesGUIImpl cannot save preferences to \'%s\': %s" \
            %(self.getConfigFile(), errdetail))

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

    \return Preferences instance.
    """
    return self.__prefs

  def defPrefs(self):
    """!\brief Retrive the default preferences.

    \return Default preferences
    """
    return self.__defPrefs

  def getConfigFile(self):
    """!\brief Retrieve the configuration file name.

    \return Configuration file name
    """
    return self.__configFile

  def refreshPrefs(self, newPrefs):
    """!\brief Refresh the preferences from \a newPrefs.

    """
    for (key, val) in newPrefs.items():
      self.__prefs[key] = val

  def setPref(self, keyword, value):
    """!\brief Set a preference value.

    \param keyword Preference keyword
    \param value   Preference value
    """
    self.__prefs[keyword] = value

  def parserToPrefs(self, confParser, prefs={}):
    """!\brief Populate preferences from the parser.

    \param confParser ConfigParser instance
    \param prefs      Preferences instance

    \return Preferences instance
    """
    # don't overwrite existing users when loading prefs
    lastuser = None
    if 'users' in prefs:
      userList = prefs['users']
    else:
      userList = rcUsers()
    sections = confParser.sections()
    for section in sections:
      if section in ('paths', 'choices', 'logging', 'system'):
        options = confParser.options(section)
        for option in options:
          prefs[option] = confParser.get(section, option)
      elif section == 'users':
        options = confParser.options(section)
        for option in options:
          value = confParser.get(section, option).split(',',1)
          if len(value) == 2:
            # Must be login id and user name separated by comma.
            user = rcUser(option, value[0].strip(), value[1].strip())
          else:
            # No login id, set the login id to be the same as user name.
            user = rcUser(option, value[0].strip(), value[0].strip())
          if option == 'lastuser':
            lastuser = user
          else:
            userList.addUser(user)
      else:
        # again don't overwrite existing lists
        if section in prefs:
          optionList = prefs[section]
        else:
          optionList = {}
        options = confParser.options(section)
        for option in options:
          if option in Preferences.LAST_ITEMS:
            prefs[option] = confParser.get(section, option)
          else:
            optionList[confParser.get(section, option)] = option
        prefs[section] = optionList
    prefs['users'] = userList
    if lastuser is None:
      # Last user hasn't been set yet, use the first id available.
      userIds = prefs["users"].getUsers().keys()
      userIds.sort()
      if len(userIds) > 0:
        lastuser = userList.getUser(userIds[0])
    if lastuser is not None:
      # Get the real user object that contains the id.
      lastuser = userList.getUserByName(lastuser.getName())
      prefs["operatorobj"] = lastuser
      prefs["operator"] = lastuser.getName()
      prefs["userid"] = lastuser.getId()

    # add _ROOT env vars to path: revisit
    if prefs.has_key('pythonpath'):
      additionalpaths = os.path.expandvars(prefs['pythonpath']).split(';')
      if prefs['pythonpath'].strip() != '':
        sys.path = map(string.strip, additionalpaths) + self.__pythonPath
    return prefs

  def prefsToParser(self):
    """!\brief Populate the parser from the preferences.

    \return ConfigParser instance
    """
    prefs = self.__prefs
    confParser = ConfigParser()
    confParser.add_section("paths")
    confParser.add_section("choices")
    confParser.add_section("logging")
    confParser.add_section("users")
    confParser.add_section("system")
    for (option, value) in prefs.items():
      if option in Preferences.DIR_LIST:
        confParser.set("paths", option, prefs.get(option))
      elif option in Preferences.CHOICE_LIST:
        confParser.set("choices", option, str(prefs[option]))
      elif option in Preferences.LOGGING_LIST:
        confParser.set("logging", option, str(prefs[option]))
      elif option in Preferences.SYSTEM_LIST:
        confParser.set("system", option, prefs[option])
      elif option == 'users':
        for (userId, user) in value.getUsers().items():
          confParser.set("users", "%03d" % int(userId), "%s,%s" % (user.getLoginId(), user.getName()))
      elif option == 'operatorobj':
        confParser.set("users", "lastuser", "%s,%s" % (value.getLoginId(), value.getName()))
      elif type(value) == types.DictType:
        if option in Preferences.EXCLUDED_DICTS:
          continue
        confParser.add_section(option)
        for (key, val) in value.items():
          confParser.set(option, val, key)
        if option == 'instrument type':
          self.processLastItem(option, 'lastinstrumenttype', confParser)
        elif option == 'phase':
          self.processLastItem(option, 'lastphase', confParser)
        elif option == 'site':
          self.processLastItem(option, 'lastsite', confParser)
        elif option == 'orientation':
          self.processLastItem(option, 'lastorientation', confParser)
        elif option == 'particle type':
          self.processLastItem(option, 'lastparticletype', confParser)
    return confParser


  def processLastItem(self, option, item, confParser):
    """!\brief Retrieve the last item of a preference and update the parser.

    \param option     Preference option name
    \param item       Preference name for the last item
    \param confParser ConfigParser instance
    """
    prefs = self.__prefs
    if prefs.has_key(item):
      last = prefs[item]
      if last == 'NOT-DEFINED':
        last = prefs.getLastItem(item)
      confParser.set(option, item, last)


  def loadDefaults(self, currentDir):
    """!\brief Load default preferences in to the parser.

    \return ConfigParser instance
    """
    cp = ConfigParser()
    cp.add_section("paths")
    cp.add_section("choices")
    cp.add_section("logging")
    cp.add_section("system")
    cp.set("paths","reposdir",currentDir)
    cp.set("paths","appdir",currentDir)
    cp.set("paths","datadir",currentDir)
    cp.set("paths","logdir",currentDir)
    cp.set("paths","reportdir",currentDir)
    cp.set("paths","snapshotdir",currentDir)
    cp.set("paths","exportdir",currentDir)
    cp.set("paths","runiddir",currentDir)
    cp.set("choices","datasave","1")
    cp.set("choices","dataexport","1")
    cp.set("choices","snapnbl","1")
    cp.set("choices","versionnbl","1")
    cp.set("choices","elognbl","0")
    cp.set("logging","lognbl","1")
    cp.set("logging","loglevel","INFO")
    cp.set("logging","loghost","localhost")
    cp.set("logging","logport",str(logging.handlers.DEFAULT_TCP_LOGGING_PORT))
    cp.set("system","pythonpath","")
    cp.set("system","elogurl","")
    cp.set("system","server","1")
    cp.set("system","servernbl","0")
    cp.set("system","dontreload","")
    cp.set("system","preload","")
    cp.set("system","disablereload","0")
    cp.set("system","showunloaded","0")
    cp.set("system","disableverification","0")

    return cp

  def isnumeric(self, str):
    """!\brief Determine whether the passed string is numeric.

    \return False if \a str is not numeric.
            True  if \a str is numeric.
    """
    return re.match('^[0-9]+$', str) is not None


  def setOperator(self, operator):
    """!\brief Set the current operator and update the configuration file.

    \param operator Operator name
    """
    operator = str(operator).strip()
    if operator == 'NOT-DEFINED':
      self.setPref("operator", operator)
      self.setPref("userid", '000')
    else:
      user = self.__prefs["users"].getUserByName(operator)
      self.setPref("operator", user.getName())
      self.setPref("operatorobj", user)
      self.setPref("userid", user.getId())
      self.writeConfig()

  def setParticleType(self, particleType):
    """!\brief Set the particle type and update the configuration file.

    \param particleType Particle type
    """
    self.setPref("lastparticletype", str(particleType))
    if particleType != 'NOT-DEFINED':
      self.writeConfig()

  def setOrientation(self, orientation):
    """!\brief Set the orientatino and update the configuration file.

    \param orientation Orientation
    """
    self.setPref("lastorientation", str(orientation))
    if orientation != 'NOT-DEFINED':
      self.writeConfig()

  def setSite(self, site):
    """!\brief Set the site and update the configuration file.

    \param site Site
    """
    self.setPref("lastsite", str(site))
    if site != 'NOT-DEFINED':
      self.writeConfig()

  def setPhase(self, phase):
    """!\brief Set the phase and update the configuration file.

    \param phase Phase
    """
    self.setPref("lastphase", str(phase))
    if phase != 'NOT-DEFINED':
      self.writeConfig()

  def setInstrumentType(self, instrumentType):
    """!\brief Set the instrument type and update the configuration file.

    \param instrumentType Instrument type
    """
    self.setPref("lastinstrumenttype", str(instrumentType))
    if instrumentType != 'NOT-DEFINED':
      self.writeConfig()


  def userId(self):
    """!\brief Get the user id.

    """
    if self.__prefs.has_key("userid"):
      return int(self.__prefs["userid"])
    else:
      return 1234


class Preferences(dict):
  """!\brief Preferences dictionary.

  Preferences needs a special dictionary class since the data it stores
  may have macros and environment variables in it.

  In order to read the values unprocessed use the self.__prefs.get(item)
  method. If you need to resolve all the macros and environment variables
  then access it like any other dictionary (self.__prefs[item])

  """
  ROOT_DIR_ENVS = ['ONLINE_ROOT']

  DIR_LIST = ("reposdir", "appdir", "datadir",
                "logdir", "reportdir",
                "snapshotdir", "exportdir", "runiddir")

  CHOICE_LIST = ("datasave", "dataexport",
                 "snapnbl", "versionnbl", "elognbl")

  LOGGING_LIST = ("lognbl", "loglevel", "loghost", "logport")

  SYSTEM_LIST = ("pythonpath", "elogurl", "server", "servernbl",
                 "fontfamily", "fontsize", "fontweight", "fontitalic",
                 "style", "preload", "dontreload", "disablereload",
                 "showunloaded", "disableverification")

  LAST_ITEMS = ("lastuser", "lastsite", "lastorientation", "lastparticletype",
                "lastinstrumenttype", "lastphase")

  TREAT_AS_INT = ("datasave", "dataexport",
                 "snapnbl", "versionnbl", "elognbl", "lognbl", "servernbl",
                 "disablereload", "showunloaded", "logport", "disableverification")

  EXCLUDED_DICTS = ("hwConfig")

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

    """
    dict.__init__(self)
    self.__saveLastItem = {}

  def __getitem__(self, item):
    """!\brief Overridden method to process the item before returning it.

    \param item Preference item
    """
    value = dict.__getitem__(self, item)
    if self.isDir(item):
      return self.expandVars(value)
    elif self.isNumber(item):
      return int(value)
    else:
      return value

  def __setitem__(self, item, value):
    """!\brief Overridden method to set the last item.

    \param item  Preference item
    \param value Preference value
    """
    if self.isLastItem(item) and value != 'NOT-DEFINED':
      self.__saveLastItem[item] = value
    dict.__setitem__(self, item, value)

  def isDir(self, item):
    """!\brief Is the item a path preference?

    \param item Preference item
    """
    return item in Preferences.DIR_LIST

  def isNumber(self, item):
    """!\brief Is the item a numeric preference?

    \param item Preference item
    """
    return item in Preferences.TREAT_AS_INT

  def isLastItem(self, item):
    """!\brief Is the preference item a last item?

    \param item Preference item
    """
    return item in Preferences.LAST_ITEMS

  def expandVars(self, path):
    """!\brief Expand the environment variables and macros in path.

    \param path Path preference value
    """
    p = os.path.expandvars(path)
    dirs = os.path.normpath(p).split(os.sep)
    i = 0
    for d in dirs:
      if d.startswith('@') and d[1:] in dict.keys(self):
        dirs[i] = dict.get(self,d[1:])

      if d.startswith('@') and d[1:] in dict.keys(self):
        if d[1:] == 'lastinstrumenttype':
          dirs[i] = dict.get(self,'instrument type')[dict.get(self,d[1:])]
        else:
          dirs[i] = dict.get(self,d[1:])

      i+=1
    if not dirs[0].endswith(os.sep):
      dirs[0]+=os.sep
    return reduce(os.path.join, dirs)

  def composePath(self, path):
    """!\brief Convert the path value back to its macro form.

    \param path Path preference value
    """
    for env in Preferences.ROOT_DIR_ENVS:
      if env in os.environ:
        if os.path.normpath(path).lower().startswith(os.path.normpath(os.environ[env]).lower() + os.sep):
          return '$' + env + path[len(os.environ[env]):]
    return path

  def getLastItem(self, item):
    """!\brief Retrieve the last item for the preference.

    \param item Preference item
    """
    if item in self.__saveLastItem:
      return self.__saveLastItem[item]

---