config.hpp

Go to the documentation of this file.

 
#ifndef RAD_CONFIG_HPP
#define RAD_CONFIG_HPP
 
#include <rad/logger.hpp>
#include <rad/assert.hpp>
#include <rad/exceptions.hpp>
 
#include <config-ng/ciiConfigApi.hpp>
 
#include <boost/program_options.hpp>
#include <boost/algorithm/string.hpp>
 
#include <string>
#include <memory>
#include <optional>
#include <vector>
 
namespace bpo = boost::program_options;
 
namespace rad {
 
const char CONFIG_KEY_SEPARATOR_OLDB = '/';
//const char CONFIG_KEY_SEPARATOR_CFG = '.';
//const std::string CONFIG_DEFAULT_ROOT_NODE = "cfg";
 
const std::string KEY_CONFIG = "cfg/";
const std::string KEY_CONFIG_VERSION = KEY_CONFIG + "version";
const std::string KEY_CONFIG_MODNAME = KEY_CONFIG + "modname";
const std::string KEY_CONFIG_PROCNAME = KEY_CONFIG + "procname";
const std::string KEY_CONFIG_FILENAME = KEY_CONFIG + "filename";
const std::string KEY_CONFIG_LOG_LEVEL = KEY_CONFIG + "log_level";
const std::string KEY_CONFIG_LOG_PROPERTIES = KEY_CONFIG + "log_properties";
const std::string KEY_CONFIG_SM_SCXML = KEY_CONFIG + "sm_scxml";
const std::string KEY_CONFIG_SM_APPEND = KEY_CONFIG + "sm_scxml_append";
const std::string KEY_CONFIG_REQ_ENDPOINT = KEY_CONFIG + "req_endpoint";
const std::string KEY_CONFIG_OLDB_URI_PREFIX = KEY_CONFIG + "oldb_uri_prefix";
const std::string KEY_CONFIG_OLDB_CONN_TIMEOUT = KEY_CONFIG + "oldb_conn_timeout";
const std::string KEY_CONFIG_OLDB_ASYNC_PERIOD = KEY_CONFIG + "oldb_async_period";
const std::string KEY_CONFIG_TRS_HEALTH_ENABLED = KEY_CONFIG + "trs_health_enabled";
const std::string KEY_CONFIG_DDS_QOS_PROFILE = KEY_CONFIG + "dds_qos_profile";
const std::string KEY_CONFIG_DDS_QOS_PARTICIPANT = KEY_CONFIG + "dds_qos_participant";
 
const std::vector<std::string> KEYS_CONFIG = {
    KEY_CONFIG_VERSION,
    KEY_CONFIG_MODNAME,
    KEY_CONFIG_PROCNAME,
    KEY_CONFIG_FILENAME,
    KEY_CONFIG_LOG_LEVEL,
    KEY_CONFIG_LOG_PROPERTIES,
    KEY_CONFIG_SM_SCXML,
    KEY_CONFIG_SM_APPEND,
    KEY_CONFIG_REQ_ENDPOINT,
    KEY_CONFIG_OLDB_URI_PREFIX,
    KEY_CONFIG_OLDB_CONN_TIMEOUT,
    KEY_CONFIG_OLDB_ASYNC_PERIOD,
    KEY_CONFIG_TRS_HEALTH_ENABLED,
    KEY_CONFIG_DDS_QOS_PROFILE,
    KEY_CONFIG_DDS_QOS_PARTICIPANT
};
 
 
class Config {
 public:
    explicit Config(const std::string& name = LOGGER_NAME,
                    const std::string& log_level = "ERROR");
 
    Config(const Config& cfg);
 
    virtual ~Config();
 
    Config& operator=(const Config& cfg);
 
    inline const elt::configng::CiiConfigDocument&  GetConfigDoc() const { return *m_config_doc; }
 
    inline bpo::options_description& GetOptionsDesc() { return m_options_desc; }
 
    inline bpo::variables_map& GetOptionsMap() { return m_options_map; }
 
    inline const std::string& GetOldbPrefixAppenderKey() { return m_oldb_prefix_appender_key; }
 
    inline void SetOldbPrefixAppenderKey(const std::string& key) {
        m_oldb_prefix_appender_key = key;
    }
 
    std::string BuildOldbPrefix();
 
    virtual bool ParseOptions(int argc, char* argv[]);
 
    virtual void LoadConfig(const std::string& filename = "");
 
    virtual void ConfigureLogging(const std::string& filename = "");
 
    virtual void ApplyCmdLineOptions();
 
    void CheckConfig() const;
 
    virtual void ValidateConfig(const std::vector<std::string>& keys,
                                const Config& cfg) const;
 
    void MergeConfig(const elt::configng::CiiConfigDocument& cfg_doc);
 
    void CreateDefaultConfig(const std::string& default_cfg);
 
    template<typename T>
    void AddParam(const std::string& key, const T& value);
 
    bool HasParam(const std::string& key) const;
 
    template<typename T>
    T GetParam(const std::string& key) const;
 
    template<typename T>
    void SetParam(const std::string& key, const T& value);
 
    const std::string GetConfigAsString() const;
 
    std::vector<std::string> SetConfigAsString(const std::string& config);
 
    std::string PrintNode(const elt::configng::CiiConfigInstanceNode& node,
                          const std::string& indentation) const;
 
    std::string Print(const elt::configng::CiiConfigInstanceNamespace& instances) const;
 
    std::string Print() const;
 
 private:
    bool SplitKeyValue(const std::string& keyval, std::string& key, std::string& value) const;
 
    void SplitVectorStr(const std::string& vector_str, std::string& vector_name,
            int& vector_index) const;
 
    bpo::options_description m_options_desc;
    bpo::variables_map m_options_map;
    std::string m_name;
 
    /*
     * Key to be used to build the OLDB prefix:
     * - If m_oldb_prefix_appender_key is an empty string, the OLDB prefix will
     *   be only the value associated with the KEY_CONFIG_OLDB_URI_PREFIX key.
     * - Otherwise m_oldb_prefix_appender_key can be set to be the key of a
     *   configuration parameter used to OLDB prefix (see BuildOldbPrefix() method).
     *   For example, m_oldb_prefix_appender_key could be KEY_CONFIG_MODNAME or
     *   KEY_CONFIG_PROCNAME. The latter case is useful when several instances of the
     *   same application is started (e.g. two instances of the m2m3WhCtr can be started:
     *   one to control the WH of M2 and one of M3).
     *  To preserve backward compatibility, this attribute should be initialized to
     *  KEY_CONFIG_MODNAME.
     */
    std::string m_oldb_prefix_appender_key;
 
    /*
     * 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::optional<elt::configng::CiiConfigDocument> m_config_doc;
};
 
 
template<typename T>
void Config::AddParam(const std::string& key, const T& value) {
    RAD_TRACE(GetLogger());
 
    std::vector<std::string> nodes;
    std::string delim(1, CONFIG_KEY_SEPARATOR_OLDB);
    boost::split(nodes, key, boost::is_any_of(delim));
    if (nodes.size() < 2) {
        RAD_LOG_THROW(rad::Exception, GetLogger(), "Key " + key +
                " has no root/leaf node(s).");
    }
 
    /*
    builder["three"] = elt::configng::CiiConfigInstanceNode::From(3);
    builder["vector"] = elt::configng::CiiConfigInstanceNode::From(std::vector<int>{1,2,3,4,5,6},
                                                                   "!cfg.type:vector_int32");
    builder["map"]["d"] = elt::configng::CiiConfigInstanceNode::From(4);
    builder["map"]["e"] = elt::configng::CiiConfigInstanceNode::From("text");
    builder["map"]["f"] = elt::configng::CiiConfigInstanceNode::From(false, "!cfg.type:boolean");
    */
    elt::configng::CiiConfigMapBuilder builder;
 
    auto curr_node = builder[nodes[0]];
    size_t index = 1;
    while (index < nodes.size()) {
        //std::string child_node_name = nodes[index];
        curr_node = curr_node[nodes[index]];
        if (index + 1 == nodes.size()) {
            //child_node.As<T>();
            curr_node = elt::configng::CiiConfigInstanceNode::From(value);
        }
        index++;
    }
 
    if (!m_config_doc) {
        m_config_doc = elt::configng::CiiConfigDocument();
        m_config_doc->SetInstancesFromMap(builder);
    } else {
        auto document = elt::configng::CiiConfigDocument();
        document.SetInstancesFromMap(builder);
        MergeConfig(document);
    }
 
    auto issues = m_config_doc->Check();
    if (issues.HasErrors() || issues.HasWarnings()) {
        for (auto& issue : issues) {
            LOG4CPLUS_ERROR(GetLogger(), "Config. issue: " << issue.GetMessage());
            //std::cout << issue << std::endl;
        }
        RAD_LOG_THROW(rad::Exception, GetLogger(), "Error/warning while adding key " + key);
    }
}
 
template<typename T>
T Config::GetParam(const std::string& key) const {
    RAD_TRACE(GetLogger());
 
    if (!m_config_doc) {
        RAD_LOG_THROW(rad::Exception, GetLogger(), "No configuration available.");
    }
 
    try {
        std::vector<std::string> nodes;
        std::string delim(1, CONFIG_KEY_SEPARATOR_OLDB);
        boost::split(nodes, key, boost::is_any_of(delim));
        if (nodes.size() < 2) {
            RAD_LOG_THROW(rad::Exception, GetLogger(), "Key " + key +
                    " has no root/leaf node(s).");
        }
 
        auto instance = m_config_doc->Instances();
        auto parent_node  = instance[nodes[0]];
        auto child_node = parent_node;
        size_t index = 1;
        while (index < nodes.size()) {
            std::string child_node_name = nodes[index];
 
            // check for arrays
            int vector_index = -1;
            SplitVectorStr(nodes[index], child_node_name, vector_index);
            //std::cout << "Child node name: " << child_node_name << std::endl;
 
            // check for sub-node or leaf-node.
            if (parent_node.Has(child_node_name)) {
                if (vector_index == -1) {
                    child_node = parent_node[child_node_name];
                } else {
                    child_node = parent_node[child_node_name][vector_index];
                }
                if (index + 1 == nodes.size()) {
                    T val = child_node.As<T>();
                    return val;
                }
                parent_node = child_node;
            } else {
                RAD_LOG_THROW(rad::Exception, GetLogger(), "Configuration parameter " +
                        key + " does not exists.");
            }
            index++;
        }
        RAD_LOG_THROW(rad::Exception, GetLogger(), "Configuration parameter " +
                key + " does not exists.");
    } catch (std::exception& e) {
        RAD_LOG_THROW(rad::Exception, GetLogger(), "Reading configuration parameter <" +
                key + ">: " + std::string(e.what()));
    }
}
 
template<typename T>
void Config::SetParam(const std::string& key, const T& value) {
    RAD_TRACE(GetLogger());
 
    if (!m_config_doc) {
        RAD_LOG_THROW(rad::Exception, GetLogger(), "No configuration available.");
    }
 
    try {
        std::vector<std::string> nodes;
        std::string delim(1, CONFIG_KEY_SEPARATOR_OLDB);
        boost::split(nodes, key, boost::is_any_of(delim));
        if (nodes.size() < 2) {
            RAD_LOG_THROW(rad::Exception, GetLogger(), "Key " + key +
                    " has no root/leaf node(s).");
        }
 
        auto instance = m_config_doc->Instances();
        auto parent_node  = instance[nodes[0]];
        auto child_node = parent_node;
        size_t index = 1;
        while (index < nodes.size()) {
            std::string child_node_name = nodes[index];
 
            // check for arrays
            int vector_index = -1;
            SplitVectorStr(nodes[index], child_node_name, vector_index);
 
            // check for sub-node or leaf-node.
            if (parent_node.Has(child_node_name)) {
                if (vector_index == -1) {
                    child_node = parent_node[child_node_name];
                } else {
                    child_node = parent_node[child_node_name][vector_index];
                }
                if (index + 1 == nodes.size()) {
                    child_node = value;
                    return;
                }
                parent_node = child_node;
            } else {
                RAD_LOG_THROW(rad::Exception, GetLogger(), "Configuration parameter " +
                        key + " does not exists.");
            }
            index++;
        }
        RAD_LOG_THROW(rad::Exception, GetLogger(), "Configuration parameter " +
                key + " does not exists.");
    } catch (std::exception& e) {
        LOG4CPLUS_ERROR(GetLogger(), "Writing configuration parameter <"
                << key << ">: " << e.what());
    }
}
 
void GetListOfKeysFromConfig(const elt::configng::CiiConfigInstanceNode& node,
                             const std::string& prefix,
                             std::vector<std::string>& keys);
 
std::vector<std::string> GetListOfKeysFromConfig(const elt::configng::CiiConfigDocument& cfg_doc);
 
}  // namespace rad
 
#endif  // RAD_CONFIG_HPP