#!/usr/bin/env python
#
# Configuration manager singleton.
#
#######################################################################
import os
import socket
import pwd
import UserDict
import ConfigParser
from dm.common.constants import dmServiceConstants
from dm.common.exceptions.configurationError import ConfigurationError
#######################################################################
# Defaults.
DEFAULT_DM_ROOT_DIR = '/opt/dm'
DEFAULT_DM_INSTALL_DIR = '%s' # requires install dir
DEFAULT_DM_CONFIG_FILE = '%s/etc/%s.%s.conf' # requires install dir/db name/service name
DEFAULT_DM_SERVICE_NAME= 'web-service'
DEFAULT_DM_LOG_FILE = '%s/var/log/%s.%s.log' # requires install dir/db name/service name
DEFAULT_DM_CONSOLE_LOG_LEVEL = 'CRITICAL'
DEFAULT_DM_FILE_LOG_LEVEL = 'INFO'
#DEFAULT_DM_LOG_RECORD_FORMAT = '%(asctime)s,%(msecs)03d [%(levelname)s] %(module)s:%(lineno)d %(user)s@%(host)s %(name)s (%(process)d): %(message)s'
#DEFAULT_DM_LOG_RECORD_FORMAT = '%(asctime)s,%(msecs)03d %(levelname)s %(module)s:%(lineno)d %(process)d: %(message)s'
DEFAULT_DM_LOG_RECORD_FORMAT = '%(asctime)s,%(msecs)03d %(levelname)s %(process)d: %(message)s'
DEFAULT_DM_LOG_DATE_FORMAT = '%Y/%m/%d %H:%M:%S'
DEFAULT_DM_CHERRYPY_LOG_LEVEL = 'ERROR'
DEFAULT_DM_CHERRYPY_LOG_FILE = '%s/var/log/%s.%s.cherrypy.error' # requires install dir/db name/service name
DEFAULT_DM_CHERRYPY_ACCESS_FILE = '%s/var/log/%s.%s.cherrypy.access' # requires install dir/db name/service name
DEFAULT_DM_SERVICE_PORT = 22236 # 222DM
DEFAULT_DM_SERVICE_HOST = '0.0.0.0'
DEFAULT_DM_SERVICE_PROTOCOL = dmServiceConstants.DM_SERVICE_PROTOCOL_HTTP
DEFAULT_DM_WEB_SERVICE_PROTOCOL = DEFAULT_DM_SERVICE_PROTOCOL
DEFAULT_DM_DS_WEB_SERVICE_PORT = 22236 # 222DM
DEFAULT_DM_DS_WEB_SERVICE_HOST = '127.0.0.1'
DEFAULT_DM_DAQ_WEB_SERVICE_PORT = 33336 # 333DM
DEFAULT_DM_DAQ_WEB_SERVICE_HOST = '127.0.0.1'
DEFAULT_DM_CAT_WEB_SERVICE_PORT = 44436 # 444DM
DEFAULT_DM_CAT_WEB_SERVICE_HOST = '127.0.0.1'
DEFAULT_DM_PROC_WEB_SERVICE_PORT = 55536 # 555DM
DEFAULT_DM_PROC_WEB_SERVICE_HOST = '127.0.0.1'
DEFAULT_DM_DB = 'postgresql'
DEFAULT_DM_DB_HOST = '127.0.0.1'
DEFAULT_DM_DB_PORT = 11136
DEFAULT_DM_DB_PASSWORD = ''
DEFAULT_DM_DB_NAME = 'dm'
DEFAULT_DM_DB_SCHEMA = DEFAULT_DM_DB_NAME
DEFAULT_DM_DB_USER = DEFAULT_DM_DB_NAME
DEFAULT_DM_DB_PASSWORD_FILE = '%s/etc/%s.db.passwd' # requires install dir/db name
DEFAULT_DM_CONTEXT_ROOT = '/dm'
# Session cache file
DEFAULT_DM_SESSION_CACHE_FILE = None
# Enforce session credentials.
DEFAULT_DM_REQUIRE_SESSION_CREDENTIALS = False
# SSL variables
DEFAULT_DM_SSL_CA_CERT_FILE = None
DEFAULT_DM_SSL_CERT_FILE = None
DEFAULT_DM_SSL_KEY_FILE = None
# Login (user|password) files
DEFAULT_DM_LOGIN_FILE = None
DEFAULT_DM_BSS_LOGIN_FILE = None
# Station name
DEFAULT_DM_STATION_NAME = None
# Allowed experiment types
DEFAULT_DM_ALLOWED_EXPERIMENT_TYPES = None
# Beamline stuff
DEFAULT_DM_BEAMLINE_NAME = None
DEFAULT_DM_BEAMLINE_MANAGERS = None
class ConfigurationManager(UserDict.UserDict):
"""
Singleton class used for keeping system configuration data. The class
initializes its data using predefined defaults, or from certain
environment variables.
Usage:
from dm.common.utility import configurationManager
cm = configurationManager.getInstance()
cm.setConsoleLogLevel('info')
level = cm.getConsoleLogLevel()
cm['myKey'] = 'myValue'
value = cm.get('myKey')
"""
# Get singleton instance.
@classmethod
def getInstance(cls):
""" Get configuration manager singleton instance. """
from dm.common.utility.configurationManager import ConfigurationManager
try:
cm = ConfigurationManager()
except ConfigurationManager, ex:
cm = ex
return cm
# Singleton.
__instance = None
def __init__(self):
if ConfigurationManager.__instance:
raise ConfigurationManager.__instance
ConfigurationManager.__instance = self
UserDict.UserDict.__init__(self)
self['user'] = pwd.getpwuid(os.getuid())[0]
self['host'] = socket.gethostname()
self['defaultRootDir'] = DEFAULT_DM_ROOT_DIR
self.__setFromEnvVar('rootDir', 'DM_ROOT_DIR')
self['defaultInstallDir'] = DEFAULT_DM_INSTALL_DIR % self.getRootDir()
self.__setFromEnvVar('installDir', 'DM_INSTALL_DIR')
self['defaultServiceName'] = DEFAULT_DM_SERVICE_NAME
self.__setFromEnvVar('serviceName', 'DM_SERVICE_NAME')
self['defaultDbName'] = DEFAULT_DM_DB_NAME
self.__setFromEnvVar('dbName', 'DM_DB_NAME')
self.__resetDynamicDefaults()
self['defaultConsoleLogLevel'] = DEFAULT_DM_CONSOLE_LOG_LEVEL
self['defaultFileLogLevel'] = DEFAULT_DM_FILE_LOG_LEVEL
self['defaultLogRecordFormat'] = DEFAULT_DM_LOG_RECORD_FORMAT
self['defaultLogDateFormat'] = DEFAULT_DM_LOG_DATE_FORMAT
self['defaultCherrypyLogLevel'] = DEFAULT_DM_CHERRYPY_LOG_LEVEL
self['defaultServicePort'] = DEFAULT_DM_SERVICE_PORT
self['defaultServiceHost'] = DEFAULT_DM_SERVICE_HOST
self['defaultServiceProtocol'] = DEFAULT_DM_SERVICE_PROTOCOL
self['defaultWebServiceProtocol'] = DEFAULT_DM_WEB_SERVICE_PROTOCOL
self['defaultDaqWebServicePort'] = DEFAULT_DM_DAQ_WEB_SERVICE_PORT
self['defaultDaqWebServiceHost'] = DEFAULT_DM_DAQ_WEB_SERVICE_HOST
self['defaultDsWebServicePort'] = DEFAULT_DM_DS_WEB_SERVICE_PORT
self['defaultDsWebServiceHost'] = DEFAULT_DM_DS_WEB_SERVICE_HOST
self['defaultCatWebServicePort'] = DEFAULT_DM_CAT_WEB_SERVICE_PORT
self['defaultCatWebServiceHost'] = DEFAULT_DM_CAT_WEB_SERVICE_HOST
self['defaultProcWebServicePort'] = DEFAULT_DM_PROC_WEB_SERVICE_PORT
self['defaultProcWebServiceHost'] = DEFAULT_DM_PROC_WEB_SERVICE_HOST
self['defaultDb'] = DEFAULT_DM_DB
self['defaultDbHost'] = DEFAULT_DM_DB_HOST
self['defaultDbPort'] = DEFAULT_DM_DB_PORT
self['defaultDbPassword'] = DEFAULT_DM_DB_PASSWORD
self['defaultContextRoot'] = DEFAULT_DM_CONTEXT_ROOT
self['defaultSessionCacheFile'] = DEFAULT_DM_SESSION_CACHE_FILE
self['defaultRequireSessionCredentials'] = DEFAULT_DM_REQUIRE_SESSION_CREDENTIALS
self['defaultSslCaCertFile'] = DEFAULT_DM_SSL_CA_CERT_FILE
self['defaultSslCertFile'] = DEFAULT_DM_SSL_CERT_FILE
self['defaultSslKeyFile'] = DEFAULT_DM_SSL_KEY_FILE
self['defaultLoginFile'] = DEFAULT_DM_LOGIN_FILE
self['defaultBssLoginFile'] = DEFAULT_DM_BSS_LOGIN_FILE
self['defaultStationName'] = DEFAULT_DM_STATION_NAME
self['defaultAllowedExperimentTypes'] = DEFAULT_DM_ALLOWED_EXPERIMENT_TYPES
self['defaultBeamlineName'] = DEFAULT_DM_BEAMLINE_NAME
self['defaultBeamlineManagers'] = DEFAULT_DM_BEAMLINE_MANAGERS
# Settings that might come from environment variables.
self.__setFromEnvVar('logFile', 'DM_LOG_FILE')
self.__setFromEnvVar('consoleLogLevel', 'DM_CONSOLE_LOG_LEVEL')
self.__setFromEnvVar('fileLogLevel', 'DM_FILE_LOG_LEVEL')
self.__setFromEnvVar('logRecordFormat', 'DM_LOG_RECORD_FORMAT')
self.__setFromEnvVar('logDateFormat', 'DM_LOG_DATE_FORMAT')
self.__setFromEnvVar('cherrypyLogLevel', 'DM_CHERRYPY_LOG_LEVEL')
self.__setFromEnvVar('cherrypyLogFile', 'DM_CHERRYPY_LOG_FILE')
self.__setFromEnvVar('cherrypyAccessFile', 'DM_CHERRYPY_ACCESS_FILE')
self.__setFromEnvVar('serviceHost', 'DM_SERVICE_HOST')
self.__setFromEnvVar('servicePort', 'DM_SERVICE_PORT')
self.__setFromEnvVar('serviceProtocol', 'DM_SERVICE_PROTOCOL')
self.__setFromEnvVar('webServiceProtocol', 'DM_WEB_SERVICE_PROTOCOL')
self.__setFromEnvVar('daqWebServiceHost', 'DM_DAQ_WEB_SERVICE_HOST')
self.__setFromEnvVar('daqWebServicePort', 'DM_DAQ_WEB_SERVICE_PORT')
self.__setFromEnvVar('dsWebServiceHost', 'DM_DS_WEB_SERVICE_HOST')
self.__setFromEnvVar('dsWebServicePort', 'DM_DS_WEB_SERVICE_PORT')
self.__setFromEnvVar('catWebServiceHost', 'DM_CAT_WEB_SERVICE_HOST')
self.__setFromEnvVar('catWebServicePort', 'DM_CAT_WEB_SERVICE_PORT')
self.__setFromEnvVar('procWebServiceHost', 'DM_PROC_WEB_SERVICE_HOST')
self.__setFromEnvVar('procWebServicePort', 'DM_PROC_WEB_SERVICE_PORT')
self.__setFromEnvVar('contextRoot', 'DM_CONTEXT_ROOT')
self.__setFromEnvVar('sessionCacheFile', 'DM_SESSION_CACHE_FILE')
self.__setFromEnvVar('sslCaCertFile', 'DM_SSL_CA_CERT_FILE')
self.__setFromEnvVar('sslCertFile', 'DM_SSL_CERT_FILE')
self.__setFromEnvVar('sslKeyFile', 'DM_SSL_KEY_FILE')
self.__setFromEnvVar('configFile', 'DM_CONFIG_FILE')
self.__setFromEnvVar('dbPasswordFile', 'DM_DB_PASSWORD_FILE')
self.__setFromEnvVar('loginFile', 'DM_LOGIN_FILE')
self.__setFromEnvVar('bssLoginFile', 'DM_BSS_LOGIN_FILE')
self.__setFromEnvVar('stationName', 'DM_STATION_NAME')
self.__setFromEnvVar('allowedExperimentTypes', 'DM_ALLOWED_EXPERIMENT_TYPES')
self.__setFromEnvVar('beamlineName', 'DM_BEAMLINE_NAME')
self.__setFromEnvVar('beamlineManagers', 'DM_BEAMLINE_MANAGERS')
# Settings that might come from file.
self.__setFromVarFile('dbPassword', self.getDbPasswordFile())
# Variables we do not keep in a dictionary
self.configParser = None
# Reset defaults that depend on install dir and service name
def __resetDynamicDefaults(self):
self['defaultConfigFile'] = DEFAULT_DM_CONFIG_FILE % (self.getInstallDir(), self.getDbName(), self.getServiceName())
self['defaultLogFile'] = DEFAULT_DM_LOG_FILE % (self.getInstallDir(), self.getDbName(), self.getServiceName())
self['defaultCherrypyAccessFile'] = DEFAULT_DM_CHERRYPY_ACCESS_FILE % (self.getInstallDir(), self.getDbName(), self.getServiceName())
self['defaultCherrypyLogFile'] = DEFAULT_DM_CHERRYPY_LOG_FILE % (self.getInstallDir(), self.getDbName(), self.getServiceName())
self['defaultDbUser'] = self.getDbName()
self['defaultDbSchema'] = self.getDbName()
self['defaultDbPasswordFile'] = DEFAULT_DM_DB_PASSWORD_FILE % (self.getInstallDir(), self.getDbName())
# This function will ignore errors if environment variable is not set.
def __setFromEnvVar(self, key, envVar):
"""
Set value for the specified key from a given environment variable.
This function ignores errors for env. variables that are not set.
"""
try:
self[key] = os.environ[envVar]
except:
pass
# This function will ignore errors if variable file is not present.
def __setFromVarFile(self, key, varFile):
"""
Set value for the specified key from a given file. The first line
in the file is variable value.
This function ignores errors.
"""
try:
v = open(varFile, 'r').readline()
self[key] = v.lstrip().rstrip()
except Exception, ex:
pass
def __getKeyValue(self, key, default='__dm_default__'):
"""
Get value for a given key.
Keys will be of the form 'logFile', and the default keys have
the form 'defaultLogFile'.
"""
defaultKey = "default" + key[0].upper() + key[1:]
defaultValue = self.get(defaultKey, None)
if default != '__dm_default__':
defaultValue = default
return self.get(key, defaultValue)
def setOptionsFromConfigFile(self, configSection, keyList, configFile=None):
_configFile = configFile
if _configFile is None:
_configFile = self.getConfigFile()
if _configFile is not None and os.path.exists(_configFile):
configParser = ConfigParser.RawConfigParser()
configParser.read(_configFile)
if not configParser.has_section(configSection):
return
for key in keyList:
if configParser.has_option(configSection, key):
self[key] = configParser.get(configSection, key)
def clearConfigParser(self):
self.configParser = None
def getConfigParser(self, defaults={}):
if self.configParser is None:
configFile = self.getConfigFile()
if os.path.exists(configFile):
self.configParser = ConfigParser.ConfigParser(defaults)
self.configParser.read(configFile)
self.configParser.defaults = defaults
return self.configParser
def setConfigDefaults(self, defaults={}):
configParser = self.getConfigParser()
if configParser is not None:
configParser.defaults = defaults
def getConfigOption(self, configSection, key, defaultValue=None):
configParser = self.getConfigParser()
if self.hasConfigSection(configSection):
try:
return configParser.get(configSection, key)
except ConfigParser.NoOptionError, ex:
# ok, return default value
pass
return defaultValue
def getConfigSections(self):
configParser = self.getConfigParser()
if configParser is not None:
return configParser.sections()
return []
def hasConfigSection(self, name):
configSections = self.getConfigSections()
if name in configSections:
return True
return False
def getConfigItems(self, configSection):
configParser = self.getConfigParser()
if configParser is not None and configParser.has_section(configSection):
return configParser.items(configSection)
return []
@classmethod
def getConfigParserFromConfigFile(cls, configFile):
if not os.path.exists(configFile):
return None
configParser = ConfigParser.RawConfigParser()
configParser.read(configFile)
return configParser
@classmethod
def getOptionFromConfigParser(cls, configParser, configSection, key, defaultValue=None):
if configParser is not None and configParser.has_section(configSection):
return configParser.get(configSection, key)
else:
return defaultValue
@classmethod
def getConfigSectionsFromConfigParser(cls, configParser):
if configParser is not None:
return configParser.sections()
return []
@classmethod
def getModuleClassConstructorTuple(cls, value, creatorClass=None):
""" Extract (module,class,constructor) tuple from the given value. """
itemList = value.split('(')
if not itemList:
return ()
itemList2 = itemList[0].split('.')
moduleNameList = itemList2[0:-1]
className = itemList2[-1]
moduleName = className[0].lower() + className[1:]
# If module name list is empty, use convention
# for determining import module name (use creator class module)
if not len(moduleNameList) and creatorClass is not None:
moduleNameList = creatorClass.__module__.split('.')
moduleNameList[-1] = moduleName
if len(moduleNameList):
moduleName = '.'.join(moduleNameList)
constructor = '%s(%s' % (className, ''.join(itemList[1:]))
return (moduleName,className,constructor)
def getHost(self):
return self['host']
def getUser(self):
return self['user']
def getDefaultRootDir(self):
return self['defaultRootDir']
def setRootDir(self, rootDir):
self['rootDir'] = rootDir
def getRootDir(self, default='__dm_default__'):
return self.__getKeyValue('rootDir', default)
def getDefaultInstallDir(self):
return self['defaultInstallDir']
def setInstallDir(self, installDir):
self['installDir'] = installDir
self.__resetDynamicDefaults()
def getInstallDir(self, default='__dm_default__'):
return self.__getKeyValue('installDir', default)
def getDefaultServiceName(self):
return self['defaultServiceName']
def setServiceName(self, serviceName):
self['serviceName'] = serviceName
self.__resetDynamicDefaults()
def getServiceName(self, default='__dm_default__'):
return self.__getKeyValue('serviceName', default)
def getDefaultDbName(self):
return self['defaultDbName']
def setDbName(self, dbName):
self['dbName'] = dbName
self.__resetDynamicDefaults()
def getDbName(self, default='__dm_default__'):
return self.__getKeyValue('dbName', default)
def getDefaultLogFile(self):
return self['defaultLogFile']
def setLogFile(self, logFile):
self['logFile'] = logFile
def getLogFile(self, default='__dm_default__'):
return self.__getKeyValue('logFile', default)
def hasLogFile(self):
return self.has_key('logFile')
def getDefaultConsoleLogLevel(self):
return self['defaultConsoleLogLevel']
def setConsoleLogLevel(self, level):
self['consoleLogLevel'] = level
def getConsoleLogLevel(self, default='__dm_default__'):
return self.__getKeyValue('consoleLogLevel', default)
def getConsoleLogLevelFromEnvVar(self):
return os.environ.get('DM_CONSOLE_LOG_LEVEL')
def hasConsoleLogLevel(self):
return self.has_key('consoleLogLevel')
def getDefaultFileLogLevel(self):
return self['defaultFileLogLevel']
def setFileLogLevel(self, level):
self['fileLogLevel'] = level
def getFileLogLevel(self, default='__dm_default__'):
return self.__getKeyValue('fileLogLevel', default)
def hasFileLogLevel(self):
return self.has_key('fileLogLevel')
def getDefaultLogRecordFormat(self):
return self['defaultLogRecordFormat']
def setLogRecordFormat(self, format):
self['logRecordFormat'] = format
def getLogRecordFormat(self, default='__dm_default__'):
return self.__getKeyValue('logRecordFormat', default)
def hasLogRecordFormat(self):
return self.has_key('logRecordFormat')
def getDefaultLogDateFormat(self):
return self['defaultLogDateFormat']
def setLogDateFormat(self, format):
self['logDateFormat'] = format
def getLogDateFormat(self, default='__dm_default__'):
return self.__getKeyValue('logDateFormat', default)
def hasLogDateFormat(self):
return self.has_key('logDateFormat')
def getDefaultCherrypyLogLevel(self):
return self['defaultCherrypyLogLevel']
def setCherrypyLogLevel(self, level):
self['cherrypyLogLevel'] = level
def getCherrypyLogLevel(self, default='__dm_default__'):
return self.__getKeyValue('cherrypyLogLevel', default)
def hasCherrypyLogLevel(self):
return self.has_key('cherrypyLogLevel')
def getDefaultCherrypyLogCherrypy(self):
return self['defaultCherrypyLogFile']
def setCherrypyLogFile(self, cherrypyLogFile):
self['cherrypyLogFile'] = cherrypyLogFile
def getCherrypyLogFile(self, default='__dm_default__'):
return self.__getKeyValue('cherrypyLogFile', default)
def hasCherrypyLogFile(self):
return self.has_key('cherrypyLogFile')
def getDefaultCherrypyAccessFile(self):
return self['defaultCherrypyAccessFile']
def setCherrypyAccessFile(self, cherrypyAccessFile):
self['cherrypyAccessFile'] = cherrypyAccessFile
def getCherrypyAccessFile(self, default='__dm_default__'):
return self.__getKeyValue('cherrypyAccessFile', default)
def hasCherrypyAccessFile(self):
return self.has_key('cherrypyAccessFile')
def isDbAvailable(self):
if os.access(self.getDbPasswordFile(), os.R_OK):
return True
return False
def getDefaultServiceProtocol(self):
return self['defaultServiceProtocol']
def setServiceProtocol(self, serviceProtocol):
self['serviceProtocol'] = serviceProtocol
def getServiceProtocol(self, default='__dm_default__'):
return self.__getKeyValue('serviceProtocol', default)
def hasServiceProtocol(self):
return self.has_key('serviceProtocol')
def getDefaultServicePort(self):
return self['defaultServicePort']
def setServicePort(self, servicePort):
self['servicePort'] = servicePort
def getServicePort(self, default='__dm_default__'):
return int(self.__getKeyValue('servicePort', default))
def hasServicePort(self):
return self.has_key('servicePort')
def getDefaultServiceHost(self):
return self['defaultServiceHost']
def setServiceHost(self, serviceHost):
self['serviceHost'] = serviceHost
def getServiceHost(self, default='__dm_default__'):
return self.__getKeyValue('serviceHost', default)
def hasServiceHost(self):
return self.has_key('serviceHost')
def getDefaultWebServiceProtocol(self):
return self['defaultWebServiceProtocol']
def setWebServiceProtocol(self, webServiceProtocol):
self['webServiceProtocol'] = webServiceProtocol
def getWebServiceProtocol(self, default='__dm_default__'):
return self.__getKeyValue('webServiceProtocol', default)
def hasWebServiceProtocol(self):
return self.has_key('webServiceProtocol')
def getDefaultDaqWebServicePort(self):
return self['defaultDaqWebServicePort']
def setDaqWebServicePort(self, daqWebServicePort):
self['daqWebServicePort'] = daqWebServicePort
def getDaqWebServicePort(self, default='__dm_default__'):
return int(self.__getKeyValue('daqWebServicePort', default))
def hasDaqWebServicePort(self):
return self.has_key('daqWebServicePort')
def getDefaultDaqWebServiceHost(self):
return self['defaultDaqWebServiceHost']
def setDaqWebServiceHost(self, daqWebServiceHost):
self['daqWebServiceHost'] = daqWebServiceHost
def getDaqWebServiceHost(self, default='__dm_default__'):
return self.__getKeyValue('daqWebServiceHost', default)
def hasDaqWebServiceHost(self):
return self.has_key('daqWebServiceHost')
def getDefaultDsWebServicePort(self):
return self['defaultDsWebServicePort']
def setDsWebServicePort(self, dsWebServicePort):
self['dsWebServicePort'] = dsWebServicePort
def getDsWebServicePort(self, default='__dm_default__'):
return int(self.__getKeyValue('dsWebServicePort', default))
def hasDsWebServicePort(self):
return self.has_key('dsWebServicePort')
def getDefaultDsWebServiceHost(self):
return self['defaultDsWebServiceHost']
def setDsWebServiceHost(self, dsWebServiceHost):
self['dsWebServiceHost'] = dsWebServiceHost
def getDsWebServiceHost(self, default='__dm_default__'):
return self.__getKeyValue('dsWebServiceHost', default)
def hasDsWebServiceHost(self):
return self.has_key('dsWebServiceHost')
def getDefaultCatWebServicePort(self):
return self['defaultCatWebServicePort']
def setCatWebServicePort(self, catWebServicePort):
self['catWebServicePort'] = catWebServicePort
def getCatWebServicePort(self, default='__dm_default__'):
return int(self.__getKeyValue('catWebServicePort', default))
def hasCatWebServicePort(self):
return self.has_key('catWebServicePort')
def getDefaultCatWebServiceHost(self):
return self['defaultCatWebServiceHost']
def setCatWebServiceHost(self, catWebServiceHost):
self['catWebServiceHost'] = catWebServiceHost
def getCatWebServiceHost(self, default='__dm_default__'):
return self.__getKeyValue('catWebServiceHost', default)
def hasCatWebServiceHost(self):
return self.has_key('catWebServiceHost')
def getDefaultProcWebServicePort(self):
return self['defaultProcWebServicePort']
def setProcWebServicePort(self, procWebServicePort):
self['procWebServicePort'] = procWebServicePort
def getProcWebServicePort(self, default='__dm_default__'):
return int(self.__getKeyValue('procWebServicePort', default))
def hasProcWebServicePort(self):
return self.has_key('procWebServicePort')
def getDefaultProcWebServiceHost(self):
return self['defaultProcWebServiceHost']
def setProcWebServiceHost(self, procWebServiceHost):
self['procWebServiceHost'] = procWebServiceHost
def getProcWebServiceHost(self, default='__dm_default__'):
return self.__getKeyValue('procWebServiceHost', default)
def hasProcWebServiceHost(self):
return self.has_key('procWebServiceHost')
def getDefaultDb(self):
return self['defaultDb']
def setDb(self, db):
self['db'] = db
def getDb(self, default='__dm_default__'):
return self.__getKeyValue('db', default)
def hasDb(self):
return self.has_key('db')
def getDefaultDbHost(self):
return self['defaultDbHost']
def setDbHost(self, dbHost):
self['dbHost'] = dbHost
def getDbHost(self, default='__dm_default__'):
return self.__getKeyValue('dbHost', default)
def hasDbHost(self):
return self.has_key('dbHost')
def getDefaultDbPort(self):
return self['defaultDbPort']
def setDbPort(self, dbPort):
self['dbPort'] = dbPort
def getDbPort(self, default='__dm_default__'):
return self.__getKeyValue('dbPort', default)
def hasDbPort(self):
return self.has_key('dbPort')
def getDefaultDbPassword(self):
return self['defaultDbPassword']
def setDbPassword(self, dbPassword):
self['dbPassword'] = dbPassword
def getDbPassword(self, default='__dm_default__'):
return self.__getKeyValue('dbPassword', default)
def hasDbPassword(self):
return self.has_key('dbPassword')
def getDefaultDbPasswordFile(self):
return self['defaultDbPasswordFile']
def getDbPasswordFile(self, default='__dm_default__'):
return self.__getKeyValue('dbPasswordFile', default)
def setDbPasswordFile(self, f):
self['dbPasswordFile'] = f
def hasDbPasswordFile(self):
return self.has_key('dbPasswordFile')
def getDefaultDbUser(self):
return self['defaultDbUser']
def getDbUser(self, default='__dm_default__'):
return self.__getKeyValue('dbUser', default)
def setDbUser(self, dbUser):
self['dbUser'] = dbUser
def hasDbUser(self):
return self.has_key('dbUser')
def getDbSchema(self, default='__dm_default__'):
return self.__getKeyValue('dbSchema', default)
def getDefaultConfigFile(self):
return self['defaultConfigFile']
def setConfigFile(self, configFile):
self['configFile'] = configFile
# Must reinitialize config parser at this point
self.configParser = None
def getConfigFile(self, default='__dm_default__'):
return self.__getKeyValue('configFile', default)
def hasConfigFile(self):
return self.has_key('configFile')
def getDefaultContextRoot(self):
return self['defaultContextRoot']
def setContextRoot(self, contextRoot):
self['contextRoot'] = contextRoot
def getContextRoot(self, default='__dm_default__'):
return self.__getKeyValue('contextRoot', default)
def hasContextRoot(self):
return self.has_key('contextRoot')
def getDefaultSessionCacheFile(self):
return self['defaultSessionCacheFile']
def setSessionCacheFile(self, sessionCacheFile):
self['sessionCacheFile'] = sessionCacheFile
def getSessionCacheFile(self, default='__dm_default__'):
return self.__getKeyValue('sessionCacheFile', default)
def hasSessionCacheFile(self):
return self.has_key('sessionCacheFile')
def getDefaultRequireSessionCredentials(self):
return self['defaultRequireSessionCredentials']
def setRequireSessionCredentials(self, requireSessionCredentials):
self['requireSessionCredentials'] = requireSessionCredentials
def getRequireSessionCredentials(self, default='__dm_default__'):
return self.__getKeyValue('requireSessionCredentials', default)
def hasRequireSessionCredentials(self):
return self.has_key('requireSessionCredentials')
def getDefaultSslCaCertFile(self):
return self['defaultSslCaCertFile']
def setSslCaCertFile(self, sslCaCertFile):
self['sslCaCertFile'] = sslCaCertFile
def getSslCaCertFile(self, default='__dm_default__'):
return self.__getKeyValue('sslCaCertFile', default)
def hasSslCaCertFile(self):
return self.has_key('sslCaCertFile')
def getDefaultSslCertFile(self):
return self['defaultSslCertFile']
def setSslCertFile(self, sslCertFile):
self['sslCertFile'] = sslCertFile
def getSslCertFile(self, default='__dm_default__'):
return self.__getKeyValue('sslCertFile', default)
def hasSslCertFile(self):
return self.has_key('sslCertFile')
def getDefaultSslKeyFile(self):
return self['defaultSslKeyFile']
def setSslKeyFile(self, sslKeyFile):
self['sslKeyFile'] = sslKeyFile
def getSslKeyFile(self, default='__dm_default__'):
return self.__getKeyValue('sslKeyFile', default)
def hasSslKeyFile(self):
return self.has_key('sslKeyFile')
def getDefaultUsername(self):
return self['defaultUsername']
def setUsername(self, username):
self['username'] = username
def getUsername(self, default='__dm_default__'):
return self.__getKeyValue('username', default)
def hasUsername(self):
return self.has_key('username')
def getDefaultPassword(self):
return self['defaultPassword']
def setPassword(self, password):
self['password'] = password
def getPassword(self, default='__dm_default__'):
return self.__getKeyValue('password', default)
def hasPassword(self):
return self.has_key('password')
def getDefaultLoginFile(self):
return self['defaultLoginFile']
def getLoginFile(self, default='__dm_default__'):
return self.__getKeyValue('loginFile', default)
def setLoginFile(self, f):
self['loginFile'] = f
def hasLoginFile(self):
return self.has_key('loginFile')
def getDefaultBssLoginFile(self):
return self['defaultBssLoginFile']
def getBssLoginFile(self, default='__dm_default__'):
return self.__getKeyValue('bssLoginFile', default)
def setBssLoginFile(self, f):
self['bssLoginFile'] = f
def hasBssLoginFile(self):
return self.has_key('bssLoginFile')
def getDefaultStationName(self):
return self['defaultStationName']
def getStationName(self, default='__dm_default__'):
return self.__getKeyValue('stationName', default)
def setStationName(self, f):
self['stationName'] = f
def hasStationName(self):
return self.has_key('stationName')
def getDefaultAllowedExperimentTypes(self):
return self['defaultAllowedExperimentTypes']
def getAllowedExperimentTypes(self, default='__dm_default__'):
return self.__getKeyValue('allowedExperimentTypes', default)
def setAllowedExperimentTypes(self, f):
self['allowedExperimentTypes'] = f
def hasAllowedExperimentTypes(self):
return self.has_key('allowedExperimentTypes')
def getDefaultBeamlineName(self):
return self['defaultBeamlineName']
def getBeamlineName(self, default='__dm_default__'):
return self.__getKeyValue('beamlineName', default)
def setBeamlineName(self, f):
self['beamlineName'] = f
def hasBeamlineName(self):
return self.has_key('beamlineName')
def getDefaultBeamlineManagers(self):
return self['defaultBeamlineManagers']
def getBeamlineManagers(self, default='__dm_default__'):
return self.__getKeyValue('beamlineManagers', default)
def setBeamlineManagers(self, f):
self['beamlineManagers'] = f
def hasBeamlineManagers(self):
return self.has_key('beamlineManagers')
#######################################################################
# Testing.
if __name__ == '__main__':
cm = ConfigurationManager.getInstance()
print cm
print cm.getUsername()