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 <ifw/ccf/common/base.hpp>
 
 
namespace ifw::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 HasCurrentPar(const std::vector<std::string>& names, TYPE& value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      //auto tmp_names = CheckNodeNames(names);
      try {
        //auto tmp_node = GetNode(tmp_names);
        //value = tmp_node.As<TYPE>();
        value = GetCurrentValue<TYPE>(names);
        return true;
      } catch (...) {
        return false;
      }
    }
 
    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>();
          value = GetCurrentValue<TYPE>(tmp_names);
          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:
        std::lock_guard<std::recursive_mutex> lock(m_staging_setup_mtx);
        auto tmp_name = BuildKey(tmp_names);
        auto it = s_staging_setup_map.find(tmp_name);
        if (it != s_staging_setup_map.end()) {
          ifw::core::utils::conversion::Convert(it->second, value);
          return true;
        }
        // - then in the CII Cfg Service staging pars doc:
        if (m_staging_setup_doc.get() == nullptr) {
          return false;
        }
        try {
          if (m_staging_setup_doc.get() == nullptr) {
            return false;
          }
          auto tmp_node = GetStagingNode(tmp_names);
          value = tmp_node.As<TYPE>();
          return true;
        } catch (...) {
          return false;
        }
    }
 
    template <class TYPE>
    bool HasStagingParKey(const std::string& name, TYPE& value) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        auto tmp_name = CheckNodeName(name);
        std::lock_guard<std::recursive_mutex> lock(m_staging_setup_mtx);
        auto it = s_staging_setup_map.find(tmp_name);
        if (it != s_staging_setup_map.end()) {
          ifw::core::utils::conversion::Convert(it->second, value);
          return true;
        } else {
          try {
            if (m_staging_setup_doc.get() == nullptr) {
              return false;
            }
            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: |{}|=|{}|...",
          IFWLOC, 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: |{}|: {}", IFWLOC, 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);
          }
        }
 
        {
          std::lock_guard<std::recursive_mutex> lock(m_staging_setup_mtx);
          StoreStagingPar(tmp_name, tmp_val.str());
        }
        LOG4CPLUS_INFO(Logger(), fmt::format("Added Staging Setup Parameter: |{}|=|{}|", tmp_name,
          tmp_val.str()));
    }
 
    std::vector<std::string> GetSetupCmdStagingPars();
 
    void GetPars(std::map<std::string, std::string>& pars,
                 const std::string& pattern = "*");
 
    template <class TYPE>
    TYPE GetCurrentValue(const std::string& name) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      std::lock_guard<std::recursive_mutex> lock(m_current_setup_mtx);
      auto it = m_current_setup_map.find(name);
      if (it != m_current_setup_map.end()) {
        TYPE tmp_value;
        ifw::core::utils::conversion::Convert(it->second, tmp_value);
        return tmp_value;
      } else {
        CCFTHROW(fmt::format("{}: Parameter: |{}| not defined among Current Setup Parameters",
                 IFWLOC, name));
      }
    }
             
    template <class TYPE>
    TYPE GetCurrentValue(const std::vector<std::string>& names) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        return GetCurrentValue<TYPE>(BuildKey(CheckNodeNames(names)));
    }
  
    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 StagingSetupToString() const;
 
    std::string SetupToString() 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:
    void StoreStagingPar(const std::string& name, const std::string& value);
 
  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...
    std::recursive_mutex                      m_staging_setup_mtx;
    static std::map<std::string, std::string> s_staging_setup_map;
    // Used to preserve the order in which the Staging Parameters were added in the object.
    std::vector<std::string>                  m_staging_setup_sequence;
 
    // The Setup object contains the current setup, accepted and installed (in use).
    //std::unique_ptr<elt::configng::CiiConfigDocument> m_setup_doc;
    std::recursive_mutex               m_current_setup_mtx;
    std::map<std::string, std::string> m_current_setup_map;
  };
 
}
 
namespace ifw::ccf {
  inline ifw::ccf::common::Setup& GetSetup() {
    return ifw::ccf::common::Setup::Instance();
  }
}
 
#endif // CCF_COMMON_SETUP_HPP_H_