Forked from
DM / dm-docs
261 commits behind, 7 commits ahead of the upstream repository.
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
configurationManager.py 17.71 KiB
#!/usr/bin/env python
#
# Configuration manager singleton.
#
#######################################################################
import os
import socket
import UserDict
import pwd
from dm.common.constants import dmServiceConstants
from dm.common.exceptions.configurationError import ConfigurationError
#######################################################################
# Defaults.
DEFAULT_DM_ROOT_DIR = '/opt/dm'
DEFAULT_DM_CONFIG_FILE = '%s/etc/dm.conf' # requires root dir
DEFAULT_DM_LOG_FILE = '%s/var/log/dm.log' # requires root dir
DEFAULT_DM_LOG_CONFIG_FILE = '%s/etc/dm.log.conf' # requires root dir
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/cherrypy.error' # requires root dir
DEFAULT_DM_CHERRYPY_ACCESS_FILE = '%s/var/log/cherrypy.access' # requires root dir
DEFAULT_DM_SERVICE_PORT = 10036 # 100DM
DEFAULT_DM_SERVICE_HOST = '0.0.0.0'
DEFAULT_DM_SERVICE_PROTOCOL = dmServiceConstants.DM_SERVICE_PROTOCOL_HTTP
DEFAULT_DM_ADMIN_USERNAME = ''
DEFAULT_DM_ADMIN_PASSWORD = ''
DEFAULT_DM_DB = 'postgresql'
DEFAULT_DM_DB_HOST = 'localhost'
DEFAULT_DM_DB_PORT = 20036 # 200DM
DEFAULT_DM_DB_PASSWORD = ''
DEFAULT_DM_DB_USER = ''
DEFAULT_DM_DB_SCHEMA = 'dm'
DEFAULT_DM_DB_PASSWORD_FILE = '%s/lib/postgresql/etc/db.passwd' # requires root dir
# 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
# Get singleton instance.
def getInstance():
""" Get configuration manager singleton instance. """
from dm.common.utility.configurationManager import ConfigurationManager
try:
cm = ConfigurationManager()
except ConfigurationManager, ex:
cm = ex
return cm
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')
"""
# 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['defaultConfigFile'] = DEFAULT_DM_CONFIG_FILE % self.getRootDir()
self['defaultLogFile'] = DEFAULT_DM_LOG_FILE % self.getRootDir()
self['defaultLogConfigFile'] = DEFAULT_DM_LOG_CONFIG_FILE % self.getRootDir()
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['defaultCherrypyLogFile'] = DEFAULT_DM_CHERRYPY_LOG_FILE % self.getRootDir()
self['defaultCherrypyAccessFile'] = DEFAULT_DM_CHERRYPY_ACCESS_FILE % self.getRootDir()
self['defaultServicePort'] = DEFAULT_DM_SERVICE_PORT
self['defaultServiceHost'] = DEFAULT_DM_SERVICE_HOST
self['defaultServiceProtocol'] = DEFAULT_DM_SERVICE_PROTOCOL
self['defaultAdminUsername'] = DEFAULT_DM_ADMIN_USERNAME
self['defaultAdminPassword'] = DEFAULT_DM_ADMIN_PASSWORD
self['defaultDb'] = DEFAULT_DM_DB
self['defaultDbHost'] = DEFAULT_DM_DB_HOST
self['defaultDbPort'] = DEFAULT_DM_DB_PORT
self['defaultDbPassword'] = DEFAULT_DM_DB_PASSWORD
self['defaultDbPasswordFile'] = DEFAULT_DM_DB_PASSWORD_FILE % self.getRootDir()
self['defaultDbUser'] = DEFAULT_DM_DB_USER
self['defaultDbSchema'] = DEFAULT_DM_DB_SCHEMA
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
# Settings that might come from environment variables.
self.__setFromEnvVar('logFile', 'DM_LOG_FILE')
self.__setFromEnvVar('logConfigFile', 'DM_LOG_CONFIG_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('serviceProtocol', 'DM_SERVICE_PROTOCOL')
self.__setFromEnvVar('serviceHost', 'DM_SERVICE_HOST')
self.__setFromEnvVar('servicePort', 'DM_SERVICE_PORT')
self.__setFromEnvVar('adminUsername', 'DM_ADMIN_USERNAME')
self.__setFromEnvVar('adminPassword', 'DM_ADMIN_PASSWORD')
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')
# Settings that might come from file.
self.__setFromVarFile('dbPassword', self.getDbPasswordFile())
# 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='__internal__'):
"""
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 != '__internal__':
defaultValue = default
return self.get(key, defaultValue)
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='__internal__'):
return self.__getKeyValue('rootDir', default)
def getDefaultLogFile(self):
return self['defaultLogFile']
def setLogFile(self, logFile):
self['logFile'] = logFile
def getLogFile(self, default='__internal__'):
return self.__getKeyValue('logFile', default)
def hasLogFile(self):
return self.has_key('logFile')
def getDefaultLogConfigFile(self):
return self['defaultLogConfigFile']
def setLogConfigFile(self, logConfigFile):
self['logConfigFile'] = logConfigFile
def getLogConfigFile(self, default='__internal__'):
return self.__getKeyValue('logConfigFile', default)
def hasLogConfigFile(self):
return self.has_key('logConfigFile')
def getDefaultConsoleLogLevel(self):
return self['defaultConsoleLogLevel']
def setConsoleLogLevel(self, level):
self['consoleLogLevel'] = level
def getConsoleLogLevel(self, default='__internal__'):
return self.__getKeyValue('consoleLogLevel', default)
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='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
return self.__getKeyValue('serviceHost', default)
def hasServiceHost(self):
return self.has_key('serviceHost')
def getDefaultAdminUsername(self):
return self['defaultAdminUsername']
def setAdminUsername(self, adminUsername):
self['adminUsername'] = adminUsername
def getAdminUsername(self, default='__internal__'):
return self.__getKeyValue('adminUsername', default)
def hasAdminUsername(self):
return self.has_key('adminUsername')
def getDefaultAdminPassword(self):
return self['defaultAdminPassword']
def setAdminPassword(self, adminPassword):
self['adminPassword'] = adminPassword
def getAdminPassword(self, default='__internal__'):
return self.__getKeyValue('adminPassword', default)
def hasAdminPassword(self):
return self.has_key('adminPassword')
def getDefaultDb(self):
return self['defaultDb']
def setDb(self, db):
self['db'] = db
def getDb(self, default='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
return self.__getKeyValue('dbPassword', default)
def hasDbPassword(self):
return self.has_key('dbPassword')
def getDefaultDbPasswordFile(self):
return self['defaultDbPasswordFile']
def getDbPasswordFile(self, default='__internal__'):
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='__internal__'):
return self.__getKeyValue('dbUser', default)
def setDbUser(self, u):
self['dbUser'] = u
def hasDbUser(self):
return self.has_key('dbUser')
def getDbSchema(self):
return self['dbSchema']
def getDefaultConfigFile(self):
return self['defaultConfigFile']
def setConfigFile(self, configFile):
self['configFile'] = configFile
def getConfigFile(self, default='__internal__'):
return self.__getKeyValue('configFile', default)
def hasConfigFile(self):
return self.has_key('configFile')
def getDefaultSessionCacheFile(self):
return self['defaultSessionCacheFile']
def setSessionCacheFile(self, sessionCacheFile):
self['sessionCacheFile'] = sessionCacheFile
def getSessionCacheFile(self, default='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
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='__internal__'):
return self.__getKeyValue('sslKeyFile', default)
def hasSslKeyFile(self):
return self.has_key('sslKeyFile')
#######################################################################
# Testing.
if __name__ == '__main__':
cm = getInstance()
print cm