def _retrieveConfigDB(Key):
# prepend "linotp." if required
key = Key
if (not key.startswith("linotp.")):
if (not key.startswith("enclinotp.")):
key = u"linotp." + Key
if isinstance(key, str):
key = u'' + key
myVal = None
entries = Session.query(Config).filter(Config.Key == key).all()
if not entries:
return None
theConf = entries[0]
# other types than continous: we are done
if theConf.Type != u'C':
myVal = theConf.Value
myVal = expand_here(myVal)
return myVal
# else we have the continue type: we iterate over all entries where the
# number of entries is stored in the description as range end
_start, end = theConf.Description.split(':')
# start accumulating the value
value = theConf.Value
for i in range(int(end)):
search_key = u"%s__[%d:%d]" % (key, i, int(end))
cont_entries = Session.query(Config).filter(
Config.Key == search_key).all()
if cont_entries:
value = value + cont_entries[0].Value
return value
def _retrieveConfigDB(Key):
# prepend "linotp." if required
key = Key
if (not key.startswith("linotp.")):
if (not key.startswith("enclinotp.")):
key = u"linotp." + Key
if isinstance(key, str):
key = u'' + key
myVal = None
entries = Session.query(Config).filter(Config.Key == key).all()
if not entries:
return None
theConf = entries[0]
# other types than continous: we are done
if theConf.Type != u'C':
myVal = theConf.Value
myVal = expand_here(myVal)
return myVal
# else we have the continue type: we iterate over all entries where the
# number of entries is stored in the description as range end
_start, end = theConf.Description.split(':')
# start accumulating the value
value = theConf.Value
for i in range(int(end)):
search_key = u"%s__[%d:%d]" % (key, i, int(end))
cont_entries = Session.query(Config).filter(
Config.Key == search_key).all()
if cont_entries:
value = value + cont_entries[0].Value
return value
def _getConfigFromEnv():
linotpConfig = {}
try:
_getConfigReadLock()
for entry in env.config:
# we check for the modification time of the config file
if entry == '__file__':
fname = env.config.get('__file__')
mTime = time.localtime(os.path.getmtime(fname))
modTime = datetime(*mTime[:6])
linotpConfig['linotp.Config'] = modTime
if entry.startswith("linotp."):
linotpConfig[entry] = expand_here(env.config[entry])
if entry.startswith("enclinotp."):
linotpConfig[entry] = env.config[entry]
_releaseConfigLock()
except Exception as e:
log.exception('Error while reading config: %r' % e)
_releaseConfigLock()
return linotpConfig
def _getConfigFromEnv():
linotpConfig = {}
try:
_getConfigReadLock()
for entry in env.config:
# we check for the modification time of the config file
if entry == '__file__':
fname = env.config.get('__file__')
mTime = time.localtime(os.path.getmtime(fname))
modTime = datetime(*mTime[:6])
linotpConfig['linotp.Config'] = modTime
if entry.startswith("linotp."):
linotpConfig[entry] = expand_here(env.config[entry])
if entry.startswith("enclinotp."):
linotpConfig[entry] = env.config[entry]
_releaseConfigLock()
except Exception as e:
log.exception('Error while reading config: %r' % e)
_releaseConfigLock()
return linotpConfig
def __setitem__(self, key, val, typ=None, des=None):
'''
implemtation of the assignement operator == internal function
:param key: key of the dict
:type key: string
:param val: any value, which is put in the dict
:type val: any type
:param typ: used in the database to control if the data is encrypted
:type typ: None,string,password
:param des: literal, which describes the data
:type des: string
'''
# do some simple typing for known config entries
self._check_type(key, val)
nVal = expand_here(val)
# update this config and sync with global dict and db
res = super().__setitem__(key, nVal)
self.glo.setConfig({key: nVal})
# ----------------------------------------------------------------- --
# finally store the entry in the database and
# syncronize as well the global timestamp
now = datetime.now()
self.glo.setConfig({'linotp.Config': str(now)})
_storeConfigDB(key, val, typ, des)
_storeConfigDB('linotp.Config', now)
return res
def __setitem__(self, key, val, typ=None, des=None):
'''
implemtation of the assignement operator == internal function
:param key: key of the dict
:type key: string
:param val: any value, which is put in the dict
:type val: any type
:param typ: used in the database to control if the data is encrypted
:type typ: None,string,password
:param des: literal, which describes the data
:type des: string
'''
# do some simple typing for known config entries
self._check_type(key, val)
nVal = expand_here(val)
# update this config and sync with global dict and db
res = self.parent.__setitem__(key, nVal)
self.glo.setConfig({key: nVal})
# ----------------------------------------------------------------- --
# finally store the entry in the database and
# syncronize as well the global timestamp
now = datetime.now()
self.glo.setConfig({'linotp.Config': unicode(now)})
_storeConfigDB(key, val, typ, des)
_storeConfigDB('linotp.Config', now)
return res
def _retrieveAllConfigDB():
"""
get the server config from database with one call
remark: for support for continous entries dedicated dicts for
description and type are used for interim processing
:return: config dict
"""
config = {}
delay = False
conf_dict = {}
type_dict = {}
desc_dict = {}
cont_dict = {}
db_config = Session.query(Config).all()
# put all information in the dicts for later processing
for conf in db_config:
log.debug("[retrieveAllConfigDB] key %r:%r" % (conf.Key, conf.Value))
conf_dict[conf.Key] = conf.Value
type_dict[conf.Key] = conf.Type
desc_dict[conf.Key] = conf.Description
# a continuous entry is indicated by the type 'C' and the description
# search for the entry which starts with '0:' as it will provide the
# number of continuous entries
if conf.Type == 'C' and conf.Description[:len('0:')] == '0:':
_start, num = conf.Description.split(':')
cont_dict[conf.Key] = int(num)
# ---------------------------------------------------------------------- --
# cleanup the config from continuous entries
for key, number in cont_dict.items():
value = conf_dict[key]
for i in range(number + 1):
search_key = u"%s__[%d:%d]" % (key, i, number)
if search_key in conf_dict:
value = value + conf_dict[search_key]
del conf_dict[search_key]
conf_dict[key] = value
search_key = u"%s__[%d:%d]" % (key, number, number)
# allow the reading of none existing entries
type_dict[key] = type_dict.get(search_key)
desc_dict[key] = desc_dict.get(search_key)
# ---------------------------------------------------------------------- --
# normal processing as before continous here
for key, value in conf_dict.items():
if key.startswith("linotp.") is False:
key = u"linotp." + key
if isinstance(key, str):
key = u'' + key
nVal = expand_here(value)
config[key] = nVal
# ---------------------------------------------------------------------- --
# special treatment of encrypted_data / password:
# instead of decrypting the data during the loading of the config, the
# encrypted data is provided EncryptedData object, which allows to only
# decrypt the data when needed.
# This allows to drop the delayed loading handling
#
for key, value in config.items():
myTyp = type_dict.get(key)
if myTyp and myTyp in ['password', 'encrypted_data']:
config[key] = EncryptedData(value)
return config, False
def _retrieveAllConfigDB():
"""
get the server config from database with one call
remark: for support for continous entries dedicated dicts for
description and type are used for interim processing
:return: config dict
"""
config = {}
delay = False
conf_dict = {}
type_dict = {}
desc_dict = {}
cont_dict = {}
db_config = Session.query(Config).all()
# put all information in the dicts for later processing
for conf in db_config:
log.debug("[retrieveAllConfigDB] key %r:%r" % (conf.Key, conf.Value))
conf_dict[conf.Key] = conf.Value
type_dict[conf.Key] = conf.Type
desc_dict[conf.Key] = conf.Description
# a continuous entry is indicated by the type 'C' and the description
# search for the entry which starts with '0:' as it will provide the
# number of continuous entries
if conf.Type == 'C' and conf.Description[:len('0:')] == '0:':
_start, num = conf.Description.split(':')
cont_dict[conf.Key] = int(num)
# ---------------------------------------------------------------------- --
# cleanup the config from continuous entries
for key, number in cont_dict.items():
value = conf_dict[key]
for i in range(number + 1):
search_key = u"%s__[%d:%d]" % (key, i, number)
if search_key in conf_dict:
value = value + conf_dict[search_key]
del conf_dict[search_key]
conf_dict[key] = value
search_key = u"%s__[%d:%d]" % (key, number, number)
# allow the reading of none existing entries
type_dict[key] = type_dict.get(search_key)
desc_dict[key] = desc_dict.get(search_key)
# ---------------------------------------------------------------------- --
# normal processing as before continous here
for key, value in conf_dict.items():
if key.startswith("linotp.") is False:
key = u"linotp." + key
if isinstance(key, str):
key = u'' + key
nVal = expand_here(value)
config[key] = nVal
# ---------------------------------------------------------------------- --
# special treatment of encrypted_data / password:
# instead of decrypting the data during the loading of the config, the
# encrypted data is provided EncryptedData object, which allows to only
# decrypt the data when needed.
# This allows to drop the delayed loading handling
#
for key, value in config.items():
myTyp = type_dict.get(key)
if myTyp and myTyp in ['password', 'encrypted_data']:
config[key] = EncryptedData(value)
return config, False
