config.py

#
# Aura Engine (https://gitlab.servus.at/aura/engine)
#
# Copyright (C) 2017-2020 - The Aura Engine Team.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Affero 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/>.


import os
import os.path
import sys
import logging

from pathlib import Path
from configparser import ConfigParser


class AuraConfig:
    """
    AuraConfig Class

    Holds the Engine Configuration as in the file `engine.ini`.
    """
    instance = None
    ini_path = ""
    logger = None


    def __init__(self, ini_path="/etc/aura/engine.ini"):
        """
        Initializes the configuration, defaults to `/etc/aura/engine.ini`.
        If this file doesn't exist it uses `./config/engine.ini` from
        the project directory.

        Args:
            ini_path(String):      The path to the configuration file `engine.ini`
        """
        self.logger = logging.getLogger("AuraEngine")
        config_file = Path(ini_path)
        if not config_file.is_file():
            ini_path = "%s/config/engine.ini" % Path(__file__).parent.parent.parent.absolute()

        self.ini_path = ini_path
        self.load_config()
        AuraConfig.instance = self

        # Defaults
        self.set("config_dir", os.path.dirname(ini_path))
        self.set("install_dir", os.path.realpath(__file__ + "../../../.."))



    @staticmethod
    def config():
        """
        Retrieves the global instances of the configuration.
        """
        return AuraConfig.instance



    def set(self, key, value):
        """
        Setter for some specific config property.

        Args:
            key (String):   key
            default (*):    value
        """
        try:
            self.__dict__[key] = int(value)
        except:
            self.__dict__[key] = str(value)



    def get(self, key, default=None):
        """
        Getter for some specific config property.

        Args:
            key (String):   key
            default (*):    value
        """
        if key not in self.__dict__:
            if default:
                self.set(key, default)
            else:
                self.logger.warning("Key " + key + " not found in configfile " + self.ini_path + "!")
                return None

        return self.__dict__[key]



    def get_database_uri(self):
        """
        Retrieves the database connection string.
        """
        db_name = self.get("db_name")
        db_user = self.get("db_user")
        db_pass = str(self.get("db_pass"))
        db_host = self.get("db_host")
        db_charset = self.get("db_charset", "utf8")
        return "mysql://" + db_user + ":" + db_pass + "@" + db_host + "/" + db_name + "?charset=" + db_charset



    def load_config(self):
        """
        Set config defaults and load settings from file
        """
        if not os.path.isfile(self.ini_path):
            self.logger.critical(self.ini_path + " not found  :(")
            sys.exit(1)

        # Read the file
        f = open(self.ini_path, 'r')
        ini_str = f.read()
        f.close()

        # Parse the values
        config_parser = ConfigParser()
        try:
            config_parser.read_string(ini_str)
        except Exception as e:
            self.logger.critical("Cannot read " + self.ini_path + "! Reason: " + str(e))
            sys.exit(0)

        for section in config_parser.sections():
            for key, value in config_parser.items(section):
                v = config_parser.get(section, key).replace('"', '').strip()
                self.set(key, v)


    def to_abs_path(self, path):
        """
        Transforms any given (relative) path to an absolute paths
        derived from the project root.
        """
        if path.startswith("/"):
            return path
        else:
            return self.get("install_dir") + "/" + path


    def abs_audio_store_path(self):
        """
        Returns the absolute path to the audio store, based on the `audio_source_folder` setting.
        """
        return self.to_abs_path(self.get("audio_source_folder"))


    def abs_playlist_path(self):
        """
        Returns the absolute path to the playlist folder
        """
        return self.to_abs_path(self.get("audio_playlist_folder"))