feat(Core/Config): rework configs load system (#2566)

src/common/Configuration/Config.cpp

@@ -7,6 +7,7 @@
 #include "Config.h"
 #include "Errors.h"
 #include "Log.h"
+#include "Util.h"
 
 ConfigMgr* ConfigMgr::instance()
 {
@@ -15,37 +16,40 @@ ConfigMgr* ConfigMgr::instance()
 }
 
 // Defined here as it must not be exposed to end-users.
-bool ConfigMgr::GetValueHelper(const char* name, ACE_TString &result)
+bool ConfigMgr::GetValueHelper(const char* name, ACE_TString& result)
 {
     GuardType guard(_configLock);
 
-    if (_config.get() == 0)
+    if (!_config.get())
         return false;
 
     ACE_TString section_name;
     ACE_Configuration_Section_Key section_key;
-    const ACE_Configuration_Section_Key &root_key = _config->root_section();
+    const ACE_Configuration_Section_Key& root_key = _config->root_section();
 
     int i = 0;
-    while (_config->enumerate_sections(root_key, i, section_name) == 0)
+
+    while (!_config->enumerate_sections(root_key, i, section_name))
     {
         _config->open_section(root_key, section_name.c_str(), 0, section_key);
-        if (_config->get_string_value(section_key, name, result) == 0)
+
+        if (!_config->get_string_value(section_key, name, result))
             return true;
+
         ++i;
     }
 
     return false;
 }
 
-bool ConfigMgr::LoadInitial(char const* file)
+bool ConfigMgr::LoadInitial(std::string const& file)
 {
-    ASSERT(file);
+    ASSERT(file.c_str());
 
     GuardType guard(_configLock);
 
     _config.reset(new ACE_Configuration_Heap());
-    if (_config->open() == 0)
+    if (!_config->open())
         if (LoadData(file))
             return true;
 
@@ -53,9 +57,9 @@ bool ConfigMgr::LoadInitial(char const* file)
     return false;
 }
 
-bool ConfigMgr::LoadMore(char const* file)
+bool ConfigMgr::LoadMore(std::string const& file)
 {
-    ASSERT(file);
+    ASSERT(file.c_str());
     ASSERT(_config);
 
     GuardType guard(_configLock);
@@ -65,84 +69,79 @@ bool ConfigMgr::LoadMore(char const* file)
 
 bool ConfigMgr::Reload()
 {
-    for(std::vector<std::string>::iterator it = _confFiles.begin(); it != _confFiles.end(); ++it) {
-        if (it==_confFiles.begin()) {
-            if (!LoadInitial((*it).c_str()))
-                return false;
-        } else {
-            LoadMore((*it).c_str());
-        }
-    }
+    if (!LoadAppConfigs())
+        return false;
+
+    LoadModulesConfigs();
 
     return true;
 }
 
-bool ConfigMgr::LoadData(char const* file)
+bool ConfigMgr::LoadData(std::string const& file)
 {
-    if(std::find(_confFiles.begin(), _confFiles.end(), file) == _confFiles.end()) {
-        _confFiles.push_back(file);
-    }
-
     ACE_Ini_ImpExp config_importer(*_config.get());
-    if (config_importer.import_config(file) == 0)
+    if (!config_importer.import_config(file.c_str()))
         return true;
 
     return false;
 }
 
-std::string ConfigMgr::GetStringDefault(const char* name, const std::string &def, bool logUnused /*= true*/)
+std::string ConfigMgr::GetStringDefault(std::string const& name, const std::string& def, bool logUnused /*= true*/)
 {
     ACE_TString val;
 
-    if (GetValueHelper(name, val))
+    if (GetValueHelper(name.c_str(), val))
         return val.c_str();
     else
     {
         if (logUnused)
-            sLog->outError("-> Not found option '%s'. The default value is used (%s)", name, def.c_str());
+            sLog->outError("-> Not found option '%s'. The default value is used (%s)", name.c_str(), def.c_str());
+
         return def;
     }
 }
 
-bool ConfigMgr::GetBoolDefault(const char* name, bool def, bool logUnused /*= true*/)
+bool ConfigMgr::GetBoolDefault(std::string const& name, bool def, bool logUnused /*= true*/)
 {
     ACE_TString val;
 
-    if (!GetValueHelper(name, val))
+    if (!GetValueHelper(name.c_str(), val))
     {
         if (logUnused)
-            def ? sLog->outError("-> Not found option '%s'. The default value is used (Yes)", name) : sLog->outError("-> Not found option '%s'. The default value is used (No)", name);
+            def ? sLog->outError("-> Not found option '%s'. The default value is used (Yes)", name.c_str()) : sLog->outError("-> Not found option '%s'. The default value is used (No)", name.c_str());
+
         return def;
     }
 
-    return (val == "true" || val == "TRUE" || val == "yes" || val == "YES" ||
-        val == "1");
+    return (val == "true" || val == "TRUE" || val == "yes" || val == "YES" || val == "1");
 }
 
-int ConfigMgr::GetIntDefault(const char* name, int def, bool logUnused /*= true*/)
+int ConfigMgr::GetIntDefault(std::string const& name, int def, bool logUnused /*= true*/)
 {
     ACE_TString val;
 
-    if (GetValueHelper(name, val))
+    if (GetValueHelper(name.c_str(), val))
         return atoi(val.c_str());
     else
     {
         if (logUnused)
-            sLog->outError("-> Not found option '%s'. The default value is used (%i)", name, def);
+            sLog->outError("-> Not found option '%s'. The default value is used (%i)", name.c_str(), def);
+
         return def;
     }
 }
 
-float ConfigMgr::GetFloatDefault(const char* name, float def, bool logUnused /*= true*/)
+float ConfigMgr::GetFloatDefault(std::string const& name, float def, bool logUnused /*= true*/)
 {
     ACE_TString val;
 
-    if (GetValueHelper(name, val))
+    if (GetValueHelper(name.c_str(), val))
         return (float)atof(val.c_str());
     else
     {
         if (logUnused)
-            sLog->outError("-> Not found option '%s'. The default value is used (%f)", name, def);
+            sLog->outError("-> Not found option '%s'. The default value is used (%f)", name.c_str(), def);
+
         return def;
     }
 }
@@ -152,22 +151,25 @@ std::list<std::string> ConfigMgr::GetKeysByString(std::string const& name)
     GuardType guard(_configLock);
 
     std::list<std::string> keys;
-    if (_config.get() == 0)
+    if (!_config.get())
         return keys;
 
     ACE_TString section_name;
     ACE_Configuration_Section_Key section_key;
-    const ACE_Configuration_Section_Key &root_key = _config->root_section();
+    const ACE_Configuration_Section_Key& root_key = _config->root_section();
 
     int i = 0;
-    while (_config->enumerate_sections(root_key, i++, section_name) == 0)
+
+    while (!_config->enumerate_sections(root_key, i++, section_name))
     {
         _config->open_section(root_key, section_name.c_str(), 0, section_key);
 
         ACE_TString key_name;
         ACE_Configuration::VALUETYPE type;
+
         int j = 0;
-        while (_config->enumerate_values(section_key, j++, key_name, type) == 0)
+
+        while (!_config->enumerate_values(section_key, j++, key_name, type))
         {
             std::string temp = key_name.c_str();
 
@@ -178,3 +180,104 @@ std::list<std::string> ConfigMgr::GetKeysByString(std::string const& name)
 
     return keys;
 }
+
+void ConfigMgr::SetConfigList(std::string const& fileName, std::string const& modulesConfigList /*= ""*/)
+{
+    _initConfigFile = fileName;
+
+    if (modulesConfigList.empty())
+        return;
+
+    // Clean config list before load
+    _modulesConfigFiles.clear();
+
+    Tokenizer configFileList(modulesConfigList, ',');
+    for (auto const& itr : configFileList)
+        _modulesConfigFiles.push_back(itr);
+}
+
+bool ConfigMgr::LoadAppConfigs(std::string const& applicationName /*= "worldserver"*/)
+{
+    // #1 - Load init config file .conf.dist
+    if (!sConfigMgr->LoadInitial(_initConfigFile + ".dist"))
+    {
+        printf("Load config error. Invalid or missing dist configuration file: %s", std::string(_initConfigFile + ".dist").c_str());
+        printf("Verify that the file exists and has \'[%s]' written in the top of the file!", applicationName.c_str());
+        return false;
+    }
+
+    // #2 - Load .conf file
+    if (!sConfigMgr->LoadMore(_initConfigFile))
+    {
+        sLog->outString("");
+        sLog->outString("Load config error. Invalid or missing configuration file: %s", _initConfigFile.c_str());
+        sLog->outString("Verify that the file exists and has \'[%s]' written in the top of the file!", applicationName.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+bool ConfigMgr::LoadModulesConfigs()
+{
+    // If not modules config - load failed
+    if (_modulesConfigFiles.empty())
+        return false;
+
+    // Start loading module configs
+    std::unordered_map<std::string /*module name*/, std::string /*config variant*/> moduleConfigFiles;
+
+    moduleConfigFiles.clear();
+
+    std::string configPath = _CONF_DIR;
+
+    for (auto const& itr : _modulesConfigFiles)
+    {
+        bool IsExistDefaultConfig = true;
+        bool IsExistDistConfig = true;
+
+        std::string moduleName = itr;
+        std::string configFile = std::string(itr) + std::string(".conf");
+        std::string defaultConfig = configPath + "/" + configFile;
+
+#if AC_PLATFORM == AC_PLATFORM_WINDOWS
+        defaultConfig = configFile;
+#endif
+
+        std::string ConfigFileDist = defaultConfig + std::string(".dist");
+
+        // Load .conf.dist config
+        if (!sConfigMgr->LoadMore(ConfigFileDist.c_str()))
+        {
+            sLog->outError("> Invalid or missing dist configuration file: %s", ConfigFileDist.c_str());
+            IsExistDistConfig = false;
+        }
+
+        // Load .conf config
+        if (!sConfigMgr->LoadMore(defaultConfig.c_str()))
+            IsExistDefaultConfig = false;
+
+        // #1 - Not exist .conf and exist .conf.dist
+        if (!IsExistDefaultConfig && IsExistDistConfig)
+            moduleConfigFiles.insert(std::make_pair(moduleName, ConfigFileDist));
+        else if (!IsExistDefaultConfig && !IsExistDistConfig) // #2 - Not exist .conf and not exist .conf.dist
+            moduleConfigFiles.insert(std::make_pair(moduleName, "default hardcoded settings"));
+        else if (IsExistDefaultConfig && IsExistDistConfig)
+            moduleConfigFiles.insert(std::make_pair(moduleName, defaultConfig));
+    }
+
+    // If module configs not exist - no load
+    if (moduleConfigFiles.empty())
+        return false;
+
+    // Print modules configurations
+    sLog->outString();
+    sLog->outString("Using configuration for modules:");
+
+    for (auto const& itr : moduleConfigFiles)
+        sLog->outString("> Module (%s) using (%s)", itr.first.c_str(), itr.second.c_str());
+
+    sLog->outString();
+
+    return true;
+}