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 __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