|
|
# -*- coding: utf-8 -*-
|
|
|
|
|
|
# Copyright (C) 2010-2020 RhodeCode GmbH
|
|
|
#
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
|
# it under the terms of the GNU Affero General Public License, version 3
|
|
|
# (only), as published by the Free Software Foundation.
|
|
|
#
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
# GNU General Public License for more details.
|
|
|
#
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
#
|
|
|
# This program is dual-licensed. If you wish to learn more about the
|
|
|
# RhodeCode Enterprise Edition, including its added features, Support services,
|
|
|
# and proprietary license terms, please see https://rhodecode.com/licenses/
|
|
|
|
|
|
import os
|
|
|
import textwrap
|
|
|
import string
|
|
|
import functools
|
|
|
import logging
|
|
|
import tempfile
|
|
|
import logging.config
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
# skip keys, that are set here, so we don't double process those
|
|
|
set_keys = {
|
|
|
'__file__': ''
|
|
|
}
|
|
|
|
|
|
|
|
|
def str2bool(_str):
|
|
|
"""
|
|
|
returns True/False value from given string, it tries to translate the
|
|
|
string into boolean
|
|
|
|
|
|
:param _str: string value to translate into boolean
|
|
|
:rtype: boolean
|
|
|
:returns: boolean from given string
|
|
|
"""
|
|
|
if _str is None:
|
|
|
return False
|
|
|
if _str in (True, False):
|
|
|
return _str
|
|
|
_str = str(_str).strip().lower()
|
|
|
return _str in ('t', 'true', 'y', 'yes', 'on', '1')
|
|
|
|
|
|
|
|
|
def aslist(obj, sep=None, strip=True):
|
|
|
"""
|
|
|
Returns given string separated by sep as list
|
|
|
|
|
|
:param obj:
|
|
|
:param sep:
|
|
|
:param strip:
|
|
|
"""
|
|
|
if isinstance(obj, (basestring,)):
|
|
|
if obj in ['', ""]:
|
|
|
return []
|
|
|
|
|
|
lst = obj.split(sep)
|
|
|
if strip:
|
|
|
lst = [v.strip() for v in lst]
|
|
|
return lst
|
|
|
elif isinstance(obj, (list, tuple)):
|
|
|
return obj
|
|
|
elif obj is None:
|
|
|
return []
|
|
|
else:
|
|
|
return [obj]
|
|
|
|
|
|
|
|
|
class SettingsMaker(object):
|
|
|
|
|
|
def __init__(self, app_settings):
|
|
|
self.settings = app_settings
|
|
|
|
|
|
@classmethod
|
|
|
def _bool_func(cls, input_val):
|
|
|
if isinstance(input_val, unicode):
|
|
|
input_val = input_val.encode('utf8')
|
|
|
return str2bool(input_val)
|
|
|
|
|
|
@classmethod
|
|
|
def _int_func(cls, input_val):
|
|
|
return int(input_val)
|
|
|
|
|
|
@classmethod
|
|
|
def _list_func(cls, input_val, sep=','):
|
|
|
return aslist(input_val, sep=sep)
|
|
|
|
|
|
@classmethod
|
|
|
def _string_func(cls, input_val, lower=True):
|
|
|
if lower:
|
|
|
input_val = input_val.lower()
|
|
|
return input_val
|
|
|
|
|
|
@classmethod
|
|
|
def _float_func(cls, input_val):
|
|
|
return float(input_val)
|
|
|
|
|
|
@classmethod
|
|
|
def _dir_func(cls, input_val, ensure_dir=False, mode=0o755):
|
|
|
|
|
|
# ensure we have our dir created
|
|
|
if not os.path.isdir(input_val) and ensure_dir:
|
|
|
os.makedirs(input_val, mode=mode)
|
|
|
|
|
|
if not os.path.isdir(input_val):
|
|
|
raise Exception('Dir at {} does not exist'.format(input_val))
|
|
|
return input_val
|
|
|
|
|
|
@classmethod
|
|
|
def _file_path_func(cls, input_val, ensure_dir=False, mode=0o755):
|
|
|
dirname = os.path.dirname(input_val)
|
|
|
cls._dir_func(dirname, ensure_dir=ensure_dir)
|
|
|
return input_val
|
|
|
|
|
|
@classmethod
|
|
|
def _key_transformator(cls, key):
|
|
|
return "{}_{}".format('RC'.upper(), key.upper().replace('.', '_').replace('-', '_'))
|
|
|
|
|
|
def maybe_env_key(self, key):
|
|
|
# now maybe we have this KEY in env, search and use the value with higher priority.
|
|
|
transformed_key = self._key_transformator(key)
|
|
|
envvar_value = os.environ.get(transformed_key)
|
|
|
if envvar_value:
|
|
|
log.debug('using `%s` key instead of `%s` key for config', transformed_key, key)
|
|
|
|
|
|
return envvar_value
|
|
|
|
|
|
def env_expand(self):
|
|
|
replaced = {}
|
|
|
for k, v in self.settings.items():
|
|
|
if k not in set_keys:
|
|
|
envvar_value = self.maybe_env_key(k)
|
|
|
if envvar_value:
|
|
|
replaced[k] = envvar_value
|
|
|
set_keys[k] = envvar_value
|
|
|
|
|
|
# replace ALL keys updated
|
|
|
self.settings.update(replaced)
|
|
|
|
|
|
def enable_logging(self, logging_conf=None, level='INFO', formatter='generic'):
|
|
|
"""
|
|
|
Helper to enable debug on running instance
|
|
|
:return:
|
|
|
"""
|
|
|
|
|
|
if not str2bool(self.settings.get('logging.autoconfigure')):
|
|
|
log.info('logging configuration based on main .ini file')
|
|
|
return
|
|
|
|
|
|
if logging_conf is None:
|
|
|
logging_conf = self.settings.get('logging.logging_conf_file') or ''
|
|
|
|
|
|
if not os.path.isfile(logging_conf):
|
|
|
log.error('Unable to setup logging based on %s, '
|
|
|
'file does not exist.... specify path using logging.logging_conf_file= config setting. ', logging_conf)
|
|
|
return
|
|
|
|
|
|
with open(logging_conf, 'rb') as f:
|
|
|
ini_template = textwrap.dedent(f.read())
|
|
|
ini_template = string.Template(ini_template).safe_substitute(
|
|
|
RC_LOGGING_LEVEL=os.environ.get('RC_LOGGING_LEVEL', '') or level,
|
|
|
RC_LOGGING_FORMATTER=os.environ.get('RC_LOGGING_FORMATTER', '') or formatter
|
|
|
)
|
|
|
|
|
|
with tempfile.NamedTemporaryFile(prefix='rc_logging_', suffix='.ini', delete=False) as f:
|
|
|
log.info('Saved Temporary LOGGING config at %s', f.name)
|
|
|
f.write(ini_template)
|
|
|
|
|
|
logging.config.fileConfig(f.name)
|
|
|
os.remove(f.name)
|
|
|
|
|
|
def make_setting(self, key, default, lower=False, default_when_empty=False, parser=None):
|
|
|
input_val = self.settings.get(key, default)
|
|
|
|
|
|
if default_when_empty and not input_val:
|
|
|
# use default value when value is set in the config but it is empty
|
|
|
input_val = default
|
|
|
|
|
|
parser_func = {
|
|
|
'bool': self._bool_func,
|
|
|
'int': self._int_func,
|
|
|
'list': self._list_func,
|
|
|
'list:newline': functools.partial(self._list_func, sep='/n'),
|
|
|
'list:spacesep': functools.partial(self._list_func, sep=' '),
|
|
|
'string': functools.partial(self._string_func, lower=lower),
|
|
|
'dir': self._dir_func,
|
|
|
'dir:ensured': functools.partial(self._dir_func, ensure_dir=True),
|
|
|
'file': self._file_path_func,
|
|
|
'file:ensured': functools.partial(self._file_path_func, ensure_dir=True),
|
|
|
None: lambda i: i
|
|
|
}[parser]
|
|
|
|
|
|
envvar_value = self.maybe_env_key(key)
|
|
|
if envvar_value:
|
|
|
input_val = envvar_value
|
|
|
set_keys[key] = input_val
|
|
|
|
|
|
self.settings[key] = parser_func(input_val)
|
|
|
return self.settings[key]
|
|
|
|
