aswi2021jmsd-gitlab/src/config/configuration.py @ d55b3aff

import os

import configparser
import logging
from logging import handlers

from injector import singleton, inject

from src.constants import DEFAULT_CONNECTION_STRING, TEST_DATABASE_FILE, DEFAULT_SERVER_BASE_URL, LOG_NAME, \
    LOG_DIR, DEFAULT_LOG_LEVEL, LOG_FILENAME
from src.constants import LOG_FILE_LOCATION, LOG_FORMAT
from src.utils.logger import Logger

DATABASE_SECTION = "Database"
DATABASE_CONNECTION_STRING = "ConnectionString"

SERVER_SECTION = "Server"
SERVER_BASE_URL = "ServerBaseURL"
SERVER_LOG_LEVEL = "LogLevel"

LOG_LEVEL_MAPPING = {
    "DEBUG": logging.DEBUG,
    "INFO": logging.INFO,
    "WARNING": logging.WARNING,
    "ERROR": logging.ERROR,
    "CRITICAL": logging.CRITICAL
}


class Configuration:
    """
    Configuration class servers for injecting current application
    configuration all over the application
    """

    def __init__(self):
        """
        Constructor
        It must initialize all variables to their default values
        """
        self.config_file = None
        self.connection_string = DEFAULT_CONNECTION_STRING
        self.base_server_url = DEFAULT_SERVER_BASE_URL
        self.log_level = DEFAULT_LOG_LEVEL


def test_configuration():
    conf = Configuration()
    conf.connection_string = TEST_DATABASE_FILE
    return conf


def test_configuration_binder(binder):
    binder.bind(Configuration, to=test_configuration(), scope=singleton)


def configure_env_variable(binder):
    """
    Load configuration file stored in X509_CONFIG environment variable.
    If the file is not specified, use the default configuration
    :param binder: injector configuration binder instance
    :return: N/A
    """
    config_name = "X509_CONFIG"
    config_file = os.environ.get(config_name)
    app_configuration = Configuration()
    # if configuration file is not specified use the default configuration
    if config_file is not None and os.path.exists(config_file):
        app_configuration.config_file = config_file
        config = configparser.ConfigParser()
        config.read(config_file)

        if config[DATABASE_SECTION] is not None:
            database_config = config[DATABASE_SECTION]
            app_configuration.connection_string = database_config.get(DATABASE_CONNECTION_STRING,
                                                                      DEFAULT_CONNECTION_STRING)
        if config[SERVER_SECTION] is not None:
            server_config = config[SERVER_SECTION]
            app_configuration.base_server_url = server_config.get(SERVER_BASE_URL,
                                                                  DEFAULT_SERVER_BASE_URL)
            app_configuration.log_level = server_config.get(SERVER_LOG_LEVEL, DEFAULT_LOG_LEVEL)

    binder.bind(Configuration, to=app_configuration, scope=singleton)


def configure_logging(config: Configuration):
    if not os.path.exists(LOG_DIR):
        os.makedirs(LOG_DIR)

    handler = logging.handlers.TimedRotatingFileHandler(
        os.path.join(LOG_DIR, LOG_FILENAME),
        when='H', interval=1)
    formatter = logging.Formatter(LOG_FORMAT)
    handler.setFormatter(formatter)

    # set log level based on config file
    app_logger = logging.getLogger(LOG_NAME)
    app_logger.setLevel(LOG_LEVEL_MAPPING.get(config.log_level, logging.DEBUG))

    app_logger.addHandler(handler)

    # TODO check is 'valid'
    log = logging.getLogger('werkzeug')
    log.disabled = True