db.hpp

Go to the documentation of this file.

 
#ifndef CCFCOMMON_DB_HPP_
#define CCFCOMMON_DB_HPP_
 
#include <string>
 
#include <mal/Cii.hpp>
#include <mal/utility/LoadMal.hpp>
 
#include <rad/topicPub.hpp>
#include <rad/mal/publisher.hpp>
#include <rad/dbAdapterRedis.hpp>
#include <rad/dbAdapter.hpp>
#include <rad/smAdapter.hpp>
 
#include <Stdif.hpp>
 
#include <ifw/core/utils/bat/dbInterface.hpp>
 
#include <ifw/ccf/common/base.hpp>
#include <ifw/ccf/common/config.hpp>
#include <ifw/ccf/common/setup.hpp>
 
 
namespace ifw::ccf::common {
 
   ifw::fnd::datatype::DataType ParToIfwDataType(const std::string& par);
 
   class InternalDb {
      public:
 
      InternalDb(const std::string& prefix);
 
      ~InternalDb() {};
 
      inline bool IsConnected() { return m_connected; }
 
      inline std::string GetPrefix() { return m_prefix; }
 
      template<typename TYPE>
      void Get(const std::string& db_key, TYPE& value) {
         LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
         auto complete_key = ifw::core::utils::string::Lower(m_prefix + db_key);
         if (m_db.find(complete_key) == m_db.end()) {
            CCFTHROW(fmt::format("Key given not defined in the OLDB: {}", db_key));
         }
         ifw::core::utils::conversion::Convert(m_db[complete_key], value);
      }
 
      template<typename TYPE>
      void Set(const std::string& db_key,
               const TYPE& value) {
         LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
         LOG4CPLUS_DEBUG(Logger(), fmt::format("Writing key: {}={} in internal DB",
            m_prefix + db_key, value));
         auto complete_key = ifw::core::utils::string::Lower(m_prefix + db_key);
         m_db[complete_key] = boost::lexical_cast<std::string>(value);
      }
 
      std::map<std::string, std::string> Scan(const std::string& key, const std::string& pattern);
 
      InternalDb(const InternalDb&) = delete;             
      InternalDb& operator=(const InternalDb&) = delete;  
 
      protected:
      private:
         std::map<std::string, std::string> m_db;
         std::string m_prefix;
         bool m_connected;
   };
 
 
   class Db {
      public:
 
      static Db* s_instance;
 
      static Db& Instance();
 
      static void Simulate();
 
      static bool IsSimulated();
 
      Db();
 
      virtual ~Db();
 
      std::string GenDbPath(const std::vector<std::string>& db_key_els);
 
      std::map<std::string, std::string> Scan(const std::string& key, const std::string& pattern);
 
      bool IsConnected();
 
      std::string GetSmState();
 
      std::string GetSmStatusState();
 
      std::string GetSmStatusSubstate();
 
      // TODO: Check if possible to use the one from util::bat::DbInterface.
      void UpdateSmStatus(std::list<scxml4cpp::State*>& status);
 
      void UpdateSmStatus(const std::string& status);
 
      void PublishRecStatus(const recif::RecStatus& rec_status);
 
      template <class TYPE>
      TYPE Get(const std::string& db_key) {
         LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
         TYPE tmp_value;
         if (db_key.find(m_prefix) != std::string::npos) {
            CCFTHROW(fmt::format("OLDB keys shall be given without prefix: {}", db_key));
         }
         BEGIN_CRIT_SEC("ifw::ccf::common::Db") {
         if (!s_simulation) {
            m_cii_db.get()->Get(db_key, tmp_value);
         } else {
            m_internal_db.get()->Get(db_key, tmp_value);
         }
         } END_CRIT_SEC();
         return tmp_value;
      }
 
      template <class TYPE>
      TYPE Get2(const std::vector<std::string>& db_key_els) {
         LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
         return Get<TYPE>(GenDbPath(db_key_els));
      }
 
      std::string GetAsStr(const std::string& db_key);
 
      template <class TYPE>
      void Set(const std::string& db_key,
               const TYPE value,
               const bool force_update = false) {
         LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
         if (db_key.find(m_prefix) != std::string::npos) {
            CCFTHROW(fmt::format("OLDB keys shall be given without prefix: {}", db_key));
         }
 
         auto it = m_last_update_map.find(db_key);
         if (it == m_last_update_map.end()) {
             m_last_update_map[db_key] = 0;
         } 
         it = m_last_update_map.find(db_key);
 
         double time_now = ifw::core::utils::time::Time();
         if (!force_update && (time_now - it->second) < m_max_update_period) {
            return;
         }
 
         BEGIN_CRIT_SEC("ifw::ccf::common::Db") {
            if (!s_simulation) {
               m_cii_db.get()->Set(db_key, value);
            } else {
               m_internal_db.get()->Set(db_key, value);
            }
         } END_CRIT_SEC();
 
         m_last_update_map[db_key] = time_now;
      }
 
      template <class TYPE>
      void Set2(const std::vector<std::string>& db_key_els,
                const TYPE value,
                const bool force_update = false) {
         LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
         Set(GenDbPath(db_key_els), value, force_update);
      }
 
      void SetFromStr(const std::string& db_key,
                      const std::string& par_name,
                      const std::string& value,
                      const bool force_update = false);
 
      void SetFromStr2(const std::vector<std::string>& db_key_els,
                       const std::string& par_name,
                       const std::string& value,
                       const bool force_update = false);
 
      void SetFromStr(const std::string& db_key,
                      const std::string& value,
                      const ifw::fnd::datatype::DataType data_type,
                      const bool force_update = false);
 
      void SetFromStr2(const std::vector<std::string>& db_key_els,
                       const std::string& value,
                       const ifw::fnd::datatype::DataType data_type,
                       const bool force_update = false);
 
      void TestConnection();
 
      void UpdateStagingSetupInDb();
 
      ifw::core::utils::bat::DbInterface& GetBatDb();
 
      Db(const Db&) = delete;             
      Db& operator=(const Db&) = delete;  
 
   protected:
 
   private:
      static bool                                 s_simulation;
 
      std::string                                 m_prefix;
      std::unique_ptr<ifw::core::utils::bat::DbInterface>    m_cii_db;
      std::unique_ptr<InternalDb>                 m_internal_db;
 
      double                                      m_max_update_period{0.5};
      std::map<std::string, double>               m_last_update_map;
 
      bool m_with_pubsub;
      std::unique_ptr<rad::cii::Publisher<stdif::Status>>    m_status_publisher;
      std::unique_ptr<rad::cii::Publisher<recif::RecStatus>> m_rec_status_publisher;
 
      std::string  m_current_status; // Current state + substate.
      std::string  m_sm_state;
      std::string  m_sm_status_state;
      std::string  m_sm_status_substate;
 
      std::string  m_server_id;
   };
 
} // namespace ifw::ccf::common
 
 
namespace ifw::ccf {
   inline ifw::ccf::common::Db& GetDb() {
      return ifw::ccf::common::Db::Instance();
   }
}
 
#endif // CCFCOMMON_DB_HPP_