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 <utils/bat/dbInterface.hpp>
 
#include <ccf/common/base.hpp>
#include <ccf/common/config.hpp>
 
namespace ccf::common {
 
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& key, TYPE& value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      auto complete_key = core::utils::string::Lower(m_prefix + key);
      if (m_db.find(complete_key) == m_db.end()) {
         CCFTHROW(fmt::format("Key given not defined in the OLDB: {}", key));
      }
      core::utils::conversion::Convert(m_db[complete_key], value);
   }
 
   template<typename TYPE>
   void Set(const std::string& key,
            const TYPE& value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      LOG4CPLUS_DEBUG(Logger(), fmt::format("Writing key: {}={} in internal DB",
         m_prefix + key, value));
      auto complete_key = core::utils::string::Lower(m_prefix + 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();
 
   Db();
 
   virtual ~Db();
 
   std::string GenDbPath(const std::vector<std::string>& keys);
 
   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);
 
   // TODO: Check if possible to use the one from util::bat::DbInterface.
   void UpdateSmStatus(const std::string& status);
 
   template <class TYPE>
   TYPE Get(const std::string& key) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      TYPE tmp_value;
      if (key.find(m_prefix) != std::string::npos) {
         CCFTHROW(fmt::format("OLDB keys shall be given without prefix: {}", key));
      }
      BEGIN_CRIT_SEC("ccf::common::Db") {
        if (!s_simulation) {
           m_cii_db.get()->Get(key, tmp_value);
        } else {
          m_internal_db.get()->Get(key, tmp_value);
        }
      } END_CRIT_SEC();
      return tmp_value;
   }
 
   template <class TYPE>
   TYPE Get2(const std::vector<std::string>& keys) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      return Get<TYPE>(GenDbPath(keys));
   }
 
   std::string GetAsStr(const std::string& key);
 
   template <class TYPE>
   void Set(const std::string& key, const TYPE value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      if (key.find(m_prefix) != std::string::npos) {
         CCFTHROW(fmt::format("OLDB keys shall be given without prefix: {}", key));
      }
      BEGIN_CRIT_SEC("ccf::common::Db") {
         if (!s_simulation) {
            m_cii_db.get()->Set(key, value);
         } else {
            m_internal_db.get()->Set(key, value);
         }
      } END_CRIT_SEC();
   }
 
   template <class TYPE>
   void Set2(const std::vector<std::string>& keys,
             const TYPE value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      Set(GenDbPath(keys), value);
   }
 
   void TestConnection();
 
   Db(const Db&) = delete;             
   Db& operator=(const Db&) = delete;  
 
 protected:
 
 private:
   static bool                                         s_simulation;
 
   std::string                                         m_prefix;
   std::unique_ptr<utils::bat::DbInterface>            m_cii_db;
   std::unique_ptr<InternalDb>                         m_internal_db;
 
   bool m_with_pubsub;
   std::unique_ptr<rad::cii::Publisher<stdif::Status>> m_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 ccf::common
 
namespace ccf {
   inline ccf::common::Db& GetDb() {
      return ccf::common::Db::Instance();
   }
}
 
#endif // CCFCOMMON_DB_HPP_