setup.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_SETUP_HPP_H_
#define CCF_COMMON_SETUP_HPP_H_
 
#include <boost/exception/diagnostic_information.hpp>
 
#include <yaml-cpp/yaml.h>
 
#include <config-ng/ciiConfigApi.hpp>
 
#include <ccf/common/base.hpp>
 
// TODO: Check correct usage of const in all methods.
 
namespace ccf::common {
 
  class Setup: public Base {
  public:
 
    static Setup* s_instance;
 
    static Setup& Instance();
 
 
    Setup();
 
    ~Setup();
 
    elt::configng::CiiConfigInstanceNode& GetNode(const std::vector<std::string>& names);
 
    elt::configng::CiiConfigInstanceNode& GetStagingNode(const std::vector<std::string>& names);
 
    elt::configng::CiiConfigInstanceNode& GetNode(const elt::configng::CiiConfigDocument* doc,
                                                  const std::vector<std::string>& names);
 
    const std::string& GetRootNodeName() const;
 
    template <class TYPE>
    bool HasPar(const std::vector<std::string>& names, TYPE& value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      auto tmp_names = CheckNodeNames(names);
      if (HasStagingPar(tmp_names, value)) {
        return true;
      } else {
        try {
          auto tmp_node = GetNode(tmp_names);
          value = tmp_node.As<TYPE>();
          return true;
        } catch (...) {
          return false;
        }
      }
    }
 
    bool ParDefined(const std::string& name);
 
    template <class TYPE>
    bool HasStagingPar(const std::vector<std::string>& names, TYPE& value) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        auto tmp_names = CheckNodeNames(names);
 
        // Try first in the Staging Par map:
        auto tmp_name = BuildKey(tmp_names);
        auto it = s_staging_setup_map.find(tmp_name);
        if (it != s_staging_setup_map.end()) {
          core::utils::conversion::Convert(it->second, value);
          return true;
        }
        // - then in the CII Cfg Service doc:
        try {
          auto tmp_node = GetStagingNode(tmp_names);
          value = tmp_node.As<TYPE>();
          return true;
        } catch (...) {
          return false;
        }
    }
 
    bool HasStagingNodeKey(const std::string& name);
 
    template <class TYPE>
    bool HasStagingParKey(const std::string& name, TYPE& value) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        auto tmp_name = CheckNodeName(name);
        auto it = s_staging_setup_map.find(tmp_name);
        if (it != s_staging_setup_map.end()) {
          core::utils::conversion::Convert(it->second, value);
          return true;
        } else {
          try {
            auto tmp_node = GetStagingNode(SplitKey(tmp_name));
            value = tmp_node.As<TYPE>();
            return true;
          } catch (...) {
            return false;
          }
          return false;
        }
    }
 
    void ResetStagingSetup();
 
    template <class TYPE>
    void AddStagingPar(const std::string& name, const TYPE value) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        std::string tmp_name = CheckNodeName(name);
        LOG4CPLUS_INFO(Logger(), fmt::format("{}: Handling Staging Setup Parameter: |{}|=|{}|...",
          CCFLOC, tmp_name, value));
        // Check if parameter is defined in the 'reference setup document'.
        if (m_ref_setup_doc.get() == nullptr) {
          CCFTHROW("Must load an Init Setup as reference before submitting setup parameters");
        }
        // 1: Check if keyword is defined in the reference setup.
        try {
          GetNode(m_ref_setup_doc.get(), SplitKey(name));
        } catch (...) {
          auto err = boost::current_exception_diagnostic_information();
          CCFTHROW(fmt::format("{}: Issue handling parameter: |{}|: {}", CCFLOC, name, err));
        }
        // 2: Check if keyword value is valid according to the schema.
        // TODO: This is a workaround. the ngconfig document class does not provide a 
        // "CheckKeyword()", which could be used for this; see also 
        std::stringstream tmp_val;
        tmp_val << value;
        auto node = GetNode(m_ref_setup_doc.get(), SplitKey(name));
        node = tmp_val.str();
        m_ref_setup_doc.get()->Check();
        auto issues = m_ref_setup_doc.get()->Check();
        if (issues) {
          // Reload the Reference Staging Setup to be ready for the next check to be performed.
          m_ref_setup_doc = std::make_unique<elt::configng::CiiConfigDocument>
            (elt::configng::CiiConfigClient::Load(m_staging_setup_file));
          for (auto issue : issues) {
            auto err = fmt::format("Value: {} provided with parameter: {} not valid",
              tmp_val.str(), name);
              //, issue.GetMessageWithOrigin());
            LOG4CPLUS_WARN(Logger(), err);
            CCFTHROW(err);
          }
        }
 
        s_staging_setup_map[tmp_name] = tmp_val.str();
        LOG4CPLUS_INFO(Logger(), fmt::format("Added Staging Setup Parameter: |{}|=|{}|", tmp_name,
          tmp_val.str()));
    }
 
    const std::map<std::string, std::string>& GetSetupCmdStagingPars();
 
    void GetPars(std::map<std::string, std::string>& pars,
                 const std::string& pattern = "*");
 
    template <class TYPE>
    TYPE GetValue(const std::vector<std::string>& names) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        auto tmp_names = CheckNodeNames(names);
        TYPE tmp_value;
        if (HasPar(tmp_names, tmp_value)) {
          return tmp_value;
        } else {
          CCFTHROW("Setup parameter requested not defined: " + BuildKey(tmp_names));
        }
    }
 
    template <class TYPE>
    TYPE GetValueKey(const std::string& name) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        auto tmp_name = CheckNodeName(name);
        TYPE tmp_value;
        if (HasPar(SplitKey(tmp_name), tmp_value)) {
          return tmp_value;
        } else {
          CCFTHROW("Setup parameter requested not defined: " + tmp_name);
        }
    }
 
    void LoadStagingSetup(const std::string& filename);
 
    void AcceptStagingSetup();
 
    std::string SetupFileToString() const;
 
    std::vector<std::string> CheckNodeNames(const std::vector<std::string>& names) const;
    std::string CheckNodeName(const std::string& name) const;
 
    const elt::configng::CiiConfigDocument& GetRefSetup() const;
 
  protected:
 
  private:
    std::string m_root_node_name;
    std::string m_staging_setup_file;
 
    // Reference setup document, used as a 'dictionary' to check parameters submitted
    // in SPF format.
    std::unique_ptr<elt::configng::CiiConfigDocument> m_ref_setup_doc;
 
    // The Staging Setup contains the parameters during the handling.
 
    // => Used when the Staging Setup is loaded from a file. <=
    // Note: Not really needed as the parameters from a setup file are loaded into the
    // "s_staging_setup_map".
    std::unique_ptr<elt::configng::CiiConfigDocument> m_staging_setup_doc;
 
    // => Used when Staging Setup Parameters provided in SPF via the Setup command. <=
    // Keys are represented as SPF ("<key el1>.<key el2>....") in the map.
    // TODO: In principle it should not be necessary to declare this map as static, but if it is
    // a normal member it doesn't work...
    static std::map<std::string, std::string> s_staging_setup_map;
 
    // The Setup object contains the current setup, accepted and installed (in use).
    std::unique_ptr<elt::configng::CiiConfigDocument> m_setup_doc;
  };
 
}
 
namespace ccf {
  inline ccf::common::Setup& GetSetup() {
    return ccf::common::Setup::Instance();
  }
}
 
#endif // CCF_COMMON_SETUP_HPP_H_