rhodecode/config/settings_maker.py

# -*- 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, str):
        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, str):
            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]