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>
#include <ccf/common/setup.hpp>
 
namespace ccf::common {
 
   ccf::DataType ParToCcfDataType(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 = 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));
         }
         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 = 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("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) {
         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));
         }
         BEGIN_CRIT_SEC("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();
      }
 
      template <class TYPE>
      void Set2(const std::vector<std::string>& db_key_els,
                const TYPE value) {
         LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
         Set(GenDbPath(db_key_els), value);
      }
 
      void SetFromStr(const std::string& db_key,
                      const std::string& par_name,
                      const std::string& value);
 
      void SetFromStr2(const std::vector<std::string>& db_key_els,
                       const std::string& par_name,
                       const std::string& value);
 
      void TestConnection();
 
      void UpdateStagingSetupInDb();
 
      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<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::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 ccf::common
 
 
namespace ccf {
   inline ccf::common::Db& GetDb() {
      return ccf::common::Db::Instance();
   }
}
 
#endif // CCFCOMMON_DB_HPP_