config.hpp

Go to the documentation of this file.

 
#ifndef EXCIISERVER_CONFIG_HPP
#define EXCIISERVER_CONFIG_HPP
 
#include "logger.hpp"
 
#include <rad/assert.hpp>
#include <rad/exceptions.hpp>
 
#include <config-ng/ciiConfigApi.hpp>
 
#include <string>
#include <memory>
#include <chrono>
 
namespace exciiserver {
 
const char KEY_SEPARATOR_OLDB = '/';
const char KEY_SEPARATOR_CFG = '.';
const std::string CONFIG_ROOT_NODE = "app";
 
const std::string CONFIG_DEFAULT_VERSION         = std::string(VERSION);
const std::string CONFIG_DEFAULT_PROCNAME       = "exciiserver";
//const std::string CONFIG_DEFAULT_FILENAME       = "";  // by default use hard-coded values
const std::string CONFIG_DEFAULT_FILENAME       = "exciiserver/config.yaml";  // by default use config file values
const std::string CONFIG_DEFAULT_SCXML_FILENAME = "exciiserver/sm.xml";
const std::string CONFIG_DEFAULT_LOG_LEVEL      = "INFO";
const std::string CONFIG_DEFAULT_LOG_PROPERTIES = "exciiserver/log.properties";
const std::string CONFIG_DEFAULT_REQ_ENDPOINT   = "zpb.rr://127.0.0.1:12081/";
const std::string CONFIG_DEFAULT_OLDB_URI_PREFIX = "cii.oldb:/elt/";
const int CONFIG_DEFAULT_OLDB_CONN_TIMEOUT = 2;  // sec
 
 
class Config {
 public:
    Config();
 
    virtual ~Config();
 
    const elt::configng::CiiConfigDocument&  GetConfigDoc() { return *m_config_doc; }
 
    bool ParseOptionsAndLoad(int argc, char* argv[]);
 
    void LoadConfig(const std::string& filename = "");
 
    void ConfigureLogging(const std::string& filename = "");
 
    //void MergeConfig(const elt::configng::CiiConfigInstanceNamespace& instance);
    void MergeConfig(const elt::configng::CiiConfigDocument& cfg_doc);
 
    std::string ConvertKey(const std::string& key,
            const char src_separator,
            const char dst_separator);
 
    template<typename T>
    T GetParam(const std::string& key,
            const char separator = KEY_SEPARATOR_OLDB);
 
    template<typename T>
    void SetParam(const std::string& key, const T& value,
            const char separator = KEY_SEPARATOR_OLDB);
 
    template<typename T>
    void AddParam(const std::string& key, const T& value,
            const char separator = KEY_SEPARATOR_OLDB);
 
    void CreateDefaultConfig();
    void CreateDefaultConfig(const std::string& default_cfg);
 
    std::string PrintNode(const elt::configng::CiiConfigInstanceNode& node,
            const std::string& indentation);
 
    std::string Print(const elt::configng::CiiConfigInstanceNamespace& instances);
 
    std::string Print();
 
    Config(const Config&) = delete;              
    Config& operator=(const Config&) = delete;  
 
 private:
    /*
     * We need to declare CiiConfigDocument as pointer since it logs info
     * in the constructor and therefore uses [CII] logging before it has
     * been properly configured.
     */
    std::unique_ptr<elt::configng::CiiConfigDocument> m_config_doc;
 
    /*
     * CII Config does not allow (yet) to create an empty configuration
     * and add config parameters. Therefore we need create CiiConfigDocument
     * from a stream.
     * We build the configuration using std::stringstream to be able to use
     * the << operator.
     */
    std::stringstream m_params;
};
 
 
template<typename T>
void Config::AddParam(const std::string& key, const T& value, const char separator) {
    RAD_TRACE(GetLogger());
 
    std::string key2 = key;
    if (separator != KEY_SEPARATOR_CFG) {
        key2 = ConvertKey(key, separator, KEY_SEPARATOR_CFG);
    }
 
    m_params << "  " << key2 << ": " << value << "\n";
}
 
template<typename T>
T Config::GetParam(const std::string& key, const char separator) {
    RAD_TRACE(GetLogger());
 
    std::string key2 = key;
    if (separator != KEY_SEPARATOR_CFG) {
        key2 = ConvertKey(key, separator, KEY_SEPARATOR_CFG);
    }
 
    try {
        RAD_ASSERTPTR(m_config_doc);
        auto instance = m_config_doc->Instances();
        if (instance[CONFIG_ROOT_NODE].Has(key2)) {
            T val = instance[CONFIG_ROOT_NODE][key2].As<T>();
            return val;
        } else {
            RAD_LOG_THROW(rad::Exception, GetLogger(), "Configuration parameter " +
                    key2 + " does not exists.");
        }
    } catch (std::exception& e) {
        RAD_LOG_THROW(rad::Exception, GetLogger(), "Reading configuration parameter <" +
                key2 + ">: " + std::string(e.what()));
    }
}
 
template<typename T>
void Config::SetParam(const std::string& key, const T& value, const char separator) {
    RAD_TRACE(GetLogger());
 
    std::string key2 = key;
    if (separator != KEY_SEPARATOR_CFG) {
        key2 = ConvertKey(key, separator, KEY_SEPARATOR_CFG);
    }
 
    try {
        RAD_ASSERTPTR(m_config_doc);
        auto instance = m_config_doc->Instances();
        instance[CONFIG_ROOT_NODE][key2] = value;
    } catch (std::exception& e) {
        LOG4CPLUS_ERROR(GetLogger(), "Writing configuration parameter <"
                << key2 << ">: " << e.what());
    }
}
 
}  // namespace exciiserver
 
#endif  // EXCIISERVER_CONFIG_HPP