Config.cpp File Reference

#include "Config.h"
#include "Log.h"
#include "StringConvert.h"
#include "StringFormat.h"
#include "Tokenize.h"
#include "Util.h"
#include <algorithm>
#include <cctype>
#include <cstdlib>
#include <fstream>
#include <locale>
#include <mutex>
#include <unordered_map>
#include <unordered_set>

Go to the source code of this file.

Macros
#define	TEMPLATE_CONFIG_OPTION(__typename)    template __typename ConfigMgr::GetOption<__typename>(std::string const& name, __typename const& def, bool showLogs /*= true*/) const;

Functions
Optional< std::string >	GetEnvFromCache (std::string const &configName, std::string const &envVarName)
template<>
std::string	ConfigMgr::GetValueDefault< std::string > (std::string const &name, std::string const &def, bool showLogs) const

Macro Definition Documentation

TEMPLATE_CONFIG_OPTION

#define TEMPLATE_CONFIG_OPTION

(

__typename

)

template __typename ConfigMgr::GetOption<__typename>(std::string const& name, __typename const& def, bool showLogs /*= true*/) const;

Function Documentation

ConfigMgr::GetValueDefault< std::string >()

template<>

std::string ConfigMgr::GetValueDefault< std::string >	(	std::string const &	name,
		std::string const &	def,
		bool	showLogs
	)		const

{
    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, "ENVIRONMENT", false, false);
        }
 
        return *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, 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;
    }
 
    return itr->second;
}

References ConfigPolicy::criticalOptionSeverity, GetEnvFromCache(), LOG_INFO, and ConfigPolicy::missingOptionSeverity.

GetEnvFromCache()

Optional< std::string > GetEnvFromCache	(	std::string const &	configName,
		std::string const &	envVarName
	)

{
    auto foundInCache = _envVarCache.find(envVarName);
    Optional<std::string> foundInEnv;
    // If it's not in the cache
    if (foundInCache == _envVarCache.end())
    {
        // Check the env itself
        foundInEnv = EnvVarForIniKey(configName);
        if (foundInEnv)
        {
            // If it's found in the env, put it in the cache
            _envVarCache.emplace(envVarName, *foundInEnv);
        }
        // Return the result of checking env
        return foundInEnv;
    }
 
    return foundInCache->second;
}

Referenced by ConfigMgr::GetValueDefault< std::string >(), and ConfigMgr::GetValueDefault().