ConfigMgr Class Reference

#include "Config.h"

Public Member Functions
bool	LoadAppConfigs (bool isReload=false)
bool	LoadModulesConfigs (bool isReload=false, bool isNeedPrintInfo=true)
void	Configure (std::string const &initFileName, std::vector< std::string > args, std::string_view modulesConfigList={}, ConfigPolicy policy={})
bool	Reload ()
std::vector< std::string >	OverrideWithEnvVariablesIfAny ()
	Overrides configuration with environment variables and returns overridden keys.
std::string const	GetFilename ()
std::string const	GetConfigPath ()
std::vector< std::string > const &	GetArguments () const
std::vector< std::string >	GetKeysByString (std::string const &name)
template<class T >
T	GetOption (std::string const &name, T const &def, bool showLogs=true) const
bool	isDryRun ()
void	setDryRun (bool mode)
template<>
bool	GetOption (std::string const &name, bool const &def, bool showLogs) const

Static Public Member Functions
static ConfigMgr *	instance ()

Private Member Functions
	ConfigMgr ()=default
	ConfigMgr (ConfigMgr const &)=delete
ConfigMgr &	operator= (ConfigMgr const &)=delete
	~ConfigMgr ()=default
bool	LoadInitial (std::string const &file, bool isReload=false)
	Method used only for loading main configuration files (authserver.conf and worldserver.conf)
bool	LoadAdditionalFile (std::string file, bool isOptional=false, bool isReload=false)
template<class T >
T	GetValueDefault (std::string const &name, T const &def, bool showLogs=true) const

Private Attributes
bool	dryRun = false
std::vector< std::string >	_moduleConfigFiles

Detailed Description

Constructor & Destructor Documentation

ConfigMgr() [1/2]

ConfigMgr::ConfigMgr ( )

privatedefault

ConfigMgr() [2/2]

ConfigMgr::ConfigMgr ( ConfigMgr const &  )

privatedelete

~ConfigMgr()

ConfigMgr::~ConfigMgr ( )

privatedefault

Member Function Documentation

Configure()

void ConfigMgr::Configure	(	std::string const &	initFileName,
		std::vector< std::string >	args,
		std::string_view	modulesConfigList = {},
		ConfigPolicy	policy = {}
	)

{
    _filename = initFileName;
    _args = std::move(args);
    _policy = policy;
 
    if (char const* env = std::getenv("AC_CONFIG_POLICY"))
        _policy = ApplyPolicyString(_policy, env);
 
    _policy = ApplyPolicyFromArgs(_policy, _args);
 
    _additonalFiles.clear();
    _moduleConfigFiles.clear();
 
    // Add modules config if exist
    if (!modulesConfigList.empty())
    {
        for (auto const& itr : Acore::Tokenize(modulesConfigList, ',', false))
        {
            if (!itr.empty())
                _additonalFiles.emplace_back(itr);
        }
    }
}

References _moduleConfigFiles, and Acore::Tokenize().

GetArguments()

std::vector< std::string > const & ConfigMgr::GetArguments

(

)

const

{
    return _args;
}

GetConfigPath()

std::string const ConfigMgr::GetConfigPath

(

)

{
    std::lock_guard<std::mutex> lock(_configLock);
 
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    return "configs/";
#else
    return std::string(_CONF_DIR) + "/";
#endif
}

Referenced by LoadModulesConfigs().

GetFilename()

std::string const ConfigMgr::GetFilename

(

)

{
    std::lock_guard<std::mutex> lock(_configLock);
    return _filename;
}

GetKeysByString()

std::vector< std::string > ConfigMgr::GetKeysByString

(

std::string const &

name

)

{
    std::lock_guard<std::mutex> lock(_configLock);
 
    std::vector<std::string> keys;
 
    for (auto const& [optionName, key] : _configOptions)
    {
        if (!optionName.compare(0, name.length(), name))
        {
            keys.emplace_back(optionName);
        }
    }
 
    return keys;
}

GetOption() [1/2]

template<>

bool ConfigMgr::GetOption	(	std::string const &	name,
		bool const &	def,
		bool	showLogs
	)		const

{
    std::string val = GetValueDefault(name, std::string(def ? "1" : "0"), showLogs);
 
    auto boolVal = Acore::StringTo<bool>(val);
    if (!boolVal)
    {
        if (showLogs)
        {
            LogWithSeverity(_policy.valueErrorSeverity, _filename,
                "> Config: Bad value defined for name '{}', going to use '{}' instead",
                name, def ? "true" : "false");
        }
 
        return def;
    }
 
    return *boolVal;
}

References GetValueDefault(), and ConfigPolicy::valueErrorSeverity.

GetOption() [2/2]

template<class T >

T ConfigMgr::GetOption	(	std::string const &	name,
		T const &	def,
		bool	showLogs = true
	)		const

{
    return GetValueDefault<T>(name, def, showLogs);
}

GetValueDefault()

template<class T >

T ConfigMgr::GetValueDefault ( std::string const &  name, T const &  def, bool  showLogs = true  ) const

private

{
    std::string strValue;
 
    auto const& itr = _configOptions.find(name);
    bool notFound = itr == _configOptions.end();
    auto envVarName = GetEnvVarName(name);
    Optional<std::string> envVar = GetEnvFromCache(name, envVarName);
    if (envVar)
    {
        // If showLogs and this key/value pair wasn't found in the currently saved config
        if (showLogs && (notFound || itr->second != envVar->c_str()))
        {
            LOG_INFO("server.loading", "> Config: Found config value '{}' from environment variable '{}'.", name, envVarName );
            AddKey(name, envVar->c_str(), "ENVIRONMENT", false, false);
        }
 
        strValue = *envVar;
    }
    else if (notFound)
    {
        if (showLogs)
        {
            bool isCritical = _criticalConfigOptions.find(name) != _criticalConfigOptions.end();
            ConfigSeverity severity = isCritical ? _policy.criticalOptionSeverity : _policy.missingOptionSeverity;
 
            if (isCritical)
            {
                LogWithSeverity(severity, _filename,
                    "> Config:\n\nFATAL ERROR: Missing property {} in config file {}, add \"{} = {}\" to this file or define '{}' as an environment variable\n\nYour server cannot start without this option!",
                    name, _filename, name, Acore::ToString(def), envVarName);
            }
            else
            {
                std::string configs = _filename;
                if (!_moduleConfigFiles.empty())
                    configs += " or module config";
 
                LogWithSeverity(severity, _filename,
                    "> Config: Missing property {} in config file {}, add \"{} = {}\" to this file or define '{}' as an environment variable.",
                    name, configs, name, def, envVarName);
            }
        }
        return def;
    }
    else
    {
        strValue = itr->second;
    }
 
    auto value = Acore::StringTo<T>(strValue);
    if (!value)
    {
        if (showLogs)
        {
            LogWithSeverity(_policy.valueErrorSeverity, _filename,
                "> Config: Bad value defined for name '{}', going to use '{}' instead",
                name, Acore::ToString(def));
        }
 
        return def;
    }
 
    return *value;
}

References _moduleConfigFiles, ConfigPolicy::criticalOptionSeverity, GetEnvFromCache(), LOG_INFO, ConfigPolicy::missingOptionSeverity, Acore::ToString(), and ConfigPolicy::valueErrorSeverity.

Referenced by GetOption().

instance()

ConfigMgr * ConfigMgr::instance ( )

static

{
    static ConfigMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

isDryRun()

bool ConfigMgr::isDryRun ( )

inline

{ return dryRun; }

References dryRun.

LoadAdditionalFile()

bool ConfigMgr::LoadAdditionalFile ( std::string  file, bool  isOptional = false, bool  isReload = false  )

private

{
    std::lock_guard<std::mutex> lock(_configLock);
    return LoadFile(file, isOptional, isReload);
}

Referenced by LoadModulesConfigs().

LoadAppConfigs()

bool ConfigMgr::LoadAppConfigs

(

bool

isReload = false

)

{
    // #1 - Load init config file .conf
    if (!LoadInitial(_filename, isReload))
    {
        return false;
    }
 
    return true;
}

References LoadInitial().

Referenced by Reload().

LoadInitial()

bool ConfigMgr::LoadInitial ( std::string const &  file, bool  isReload = false  )

private

Method used only for loading main configuration files (authserver.conf and worldserver.conf)

{
    std::lock_guard<std::mutex> lock(_configLock);
    _configOptions.clear();
    return LoadFile(file, false, isReload);
}

Referenced by LoadAppConfigs().

LoadModulesConfigs()

bool ConfigMgr::LoadModulesConfigs	(	bool	isReload = false,
		bool	isNeedPrintInfo = true
	)

{
    if (_additonalFiles.empty())
    {
        // Send successful load if no found files
        return true;
    }
 
    if (isNeedPrintInfo)
    {
        LOG_INFO("server.loading", " ");
        LOG_INFO("server.loading", "Loading Modules Configuration...");
    }
 
    // Start loading module configs
    std::string const& moduleConfigPath = GetConfigPath() + "modules/";
 
    for (auto const& fileName : _additonalFiles)
    {
        bool isExistConfig = LoadAdditionalFile(moduleConfigPath + fileName, false, isReload);
 
        if (isExistConfig)
            _moduleConfigFiles.emplace_back(fileName);
    }
 
    if (isNeedPrintInfo)
    {
        if (!_moduleConfigFiles.empty())
        {
            // Print modules configurations
            LOG_INFO("server.loading", " ");
            LOG_INFO("server.loading", "Using modules configuration:");
 
            for (auto const& itr : _moduleConfigFiles)
            {
                LOG_INFO("server.loading", "> {}", itr);
            }
        }
        else
        {
            LOG_INFO("server.loading", "> Not found modules config files");
        }
    }
 
    if (isNeedPrintInfo)
    {
        LOG_INFO("server.loading", " ");
    }
 
    return true;
}

References _moduleConfigFiles, GetConfigPath(), LoadAdditionalFile(), and LOG_INFO.

Referenced by Reload().

operator=()

ConfigMgr & ConfigMgr::operator= ( ConfigMgr const &  )

privatedelete

OverrideWithEnvVariablesIfAny()

std::vector< std::string > ConfigMgr::OverrideWithEnvVariablesIfAny

(

)

Overrides configuration with environment variables and returns overridden keys.

{
    std::lock_guard<std::mutex> lock(_configLock);
 
    std::vector<std::string> overriddenKeys;
 
    for (auto& itr : _configOptions)
    {
        if (itr.first.empty())
            continue;
 
        Optional<std::string> envVar = EnvVarForIniKey(itr.first);
        if (!envVar)
            continue;
 
        itr.second = *envVar;
 
        overriddenKeys.push_back(itr.first);
    }
 
    return overriddenKeys;
}

Referenced by Reload().

Reload()

bool ConfigMgr::Reload

(

)

{
    if (!LoadAppConfigs(true))
    {
        return false;
    }
 
    if (!LoadModulesConfigs(true, false))
    {
        return false;
    }
 
    OverrideWithEnvVariablesIfAny();
 
    return true;
}

References LoadAppConfigs(), LoadModulesConfigs(), and OverrideWithEnvVariablesIfAny().

setDryRun()

void ConfigMgr::setDryRun ( bool  mode )

inline

{ dryRun = mode; }

References dryRun.

Member Data Documentation

_moduleConfigFiles

std::vector<std::string > ConfigMgr::_moduleConfigFiles

private

Referenced by Configure(), GetValueDefault(), and LoadModulesConfigs().

dryRun

bool ConfigMgr::dryRun = false

private

Referenced by isDryRun(), and setDryRun().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/common/Configuration/Config.h
• azerothcore-wotlk/src/common/Configuration/Config.cpp