deviceConfig.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_DEVICECONFIG_HPP_
#define FCF_DEVMGR_COMMON_DEVICECONFIG_HPP_
 
// System headers
#include <string>
#include <unordered_map>
 
// Third party headers
#include <yaml-cpp/yaml.h>
 
#include <utils/bat/logger.hpp>
#include <utils/bat/config.hpp>
#include <ifw/core/protocol/base/iComm.hpp>
#include <fcf/devmgr/common/iDeviceConfig.hpp>
 
// New CII Config Service
#include <config-ng/ciiConfigApi.hpp>
 
namespace fcf {
  namespace devmgr {
    namespace common {
 
      // Constants for common configuration
      constexpr auto CI_IDENTIFIER             = "identifier";
      constexpr auto CI_SIMULATED              = "simulated";
      constexpr auto CI_IGNORED                = "ignored";
      constexpr auto CI_ADDRESS                = "dev_endpoint";
      constexpr auto CI_SIM_ADDRESS            = "sim_endpoint";
      constexpr auto CI_TYPE                   = "type";
      constexpr auto CI_PREFIX                 = "prefix";
      constexpr auto CI_NAME                   = "name";
      constexpr auto CI_NAMESPACE              = "namespace";
      constexpr auto CI_MAP_FILE               = "mapfile";
      constexpr auto CI_FITS_PREFIX            = "fits_prefix";
      constexpr auto CI_ALIAS                  = "alias";
      constexpr auto CI_ID                     = "id";
      constexpr auto CI_OVERVIEW               = "overview";
      constexpr auto CI_DESCRIPTION            = "description";
      constexpr auto CI_CFG_FILE               = "cfgfile";
      constexpr auto CI_CTRL_CONFIG            = "ctrl_config";
      constexpr auto CI_WIDGET                 = "widget";
      constexpr auto CI_WIDGET_MODULE          = "module";
      constexpr auto CI_WIDGET_CLASS           = "class";
      constexpr auto CI_WIDGET_WIDGET          = "widget";
      constexpr auto CI_WIDGET_HEIGHT          = "height";
 
 
      // Constants for common RPC calls
      constexpr auto RPC_INIT                  = "rpcInit";
      constexpr auto RPC_ENABLE                = "rpcEnable";
      constexpr auto RPC_DISABLE               = "rpcDisable";
      constexpr auto RPC_STOP                  = "rpcStop";
      constexpr auto RPC_RESET                 = "rpcReset";
 
      // Constants for common status attributes
      constexpr auto CI_STAT_SUBSTATE          = "substate";
      constexpr auto CI_STAT_STATE             = "state";
      constexpr auto CI_STAT_STATU             = "status";
      constexpr auto CI_STAT_LOCAL             = "local";
      constexpr auto CI_STAT_ERROR_CODE        = "error_code";
      constexpr auto CI_STAT_ERROR_STR         = "error_str";
      constexpr auto DB_CONTROLLER_PREFIX      = "lcs";
 
      // Constants for address categories
      constexpr auto CAT_STAT                  = "stat";
      constexpr auto CAT_CFG                   = "cfg";
      constexpr auto CAT_CTRL                  = "ctrl";
      constexpr auto CAT_RPC                   = "rpc";
 
      // Constants for state values
      constexpr int STATE_NOT_OPERATIONAL      =  1;
      constexpr int STATE_OPERATIONAL          =  2;
 
      constexpr auto STATE_NOT_OPERATIONAL_STR =  "NotOperational";
      constexpr auto STATE_OPERATIONAL_STR     =  "Operational";
      constexpr auto STATE_UNAVAILABLE_STR     =  "Unavailable";
 
      const std::unordered_map<short, std::string>  StateMap = {
        {STATE_NOT_OPERATIONAL,       STATE_NOT_OPERATIONAL_STR},
        {STATE_OPERATIONAL,   STATE_OPERATIONAL_STR},
      };
 
      const std::unordered_map<std::string, short>  StateStrMap = {
        {STATE_NOT_OPERATIONAL_STR,       STATE_NOT_OPERATIONAL},
        {STATE_OPERATIONAL_STR,   STATE_OPERATIONAL},
      };
 
      // Constants for substate values
      constexpr int SUBSTATE_NOTREADY        =  100;
      constexpr int SUBSTATE_READY           =  101;
      constexpr int SUBSTATE_INITIALISING    =  102;
      constexpr int SUBSTATE_ERROR           =  199;
 
      constexpr auto SUBSTATE_NOTREADY_STR     =  "NotReady";
      constexpr auto SUBSTATE_INITIALISING_STR =  "Initialising";
      constexpr auto SUBSTATE_READY_STR        =  "Ready";
      constexpr auto SUBSTATE_ERROR_STR        =  "Error";
 
      constexpr int SUBSTATE_OP_DISABLING      =  205;
      constexpr int SUBSTATE_OP_ERROR          =  299;
 
      constexpr auto SUBSTATE_OP_DISABLING_STR =  "Disabling";
      constexpr auto SUBSTATE_OP_ERROR_STR     =  "OpError";
 
      constexpr auto FITS_PARAM_ID             = "ID";
      constexpr auto FITS_PARAM_NAME           = "NAME";
      constexpr auto FITS_PARAM_STAT           = "STAT";
      constexpr auto FITS_PARAM_DEVSIM         = "DEVSIM";
      constexpr auto FITS_PARAM_DEVIGN         = "DEVIGN";
 
      class DeviceConfig : public IDeviceConfig {
 
      public:
          enum NodeIdType {
              ATTRIB_NODE_ID,
              RPC_NODE_ID,
              OBJ_NODE_ID
          };
        DeviceConfig(const std::string& filename, const std::string& name);
 
        DeviceConfig(const std::string& name);
 
        virtual ~DeviceConfig();
 
        bool Init();
 
        void InitFromString(std::string config);
 
        void InitFromFile(const std::string& filename);
 
        virtual void GetConfig(protocol::base::VectorVariant& params) const;
 
        std::string  GetIdentifier() const;
 
        std::string  GetPrefix() const;
 
        std::string  GetAddress() const ;
 
        /*
       *
       * @return device simulation address
       */
        std::string  GetSimAddress() const;
 
        std::string  GetFitsPrefix() const;
 
 
        std::string  GetType() const;
 
        int GetNamespace() const;
 
        std::string  GetAlias() const;
 
        std::string  GetId() const;
 
        std::string  GetOverview() const;
 
        std::string  GetDescription() const;
 
        inline std::string  GetName() const noexcept {return m_name;};
 
       inline std::string  GetLogName() const noexcept {
          const string name = "[" + m_name + "]";
          return name;
        };
 
        std::string  GetNodeIdByType(const std::string& attrib, const NodeIdType type = ATTRIB_NODE_ID) const;
        std::string  GetNodeId(const std::string& attrib) const;
 
        std::string  GetProcId(const std::string& attrib) const;
 
        std::string  GetObjId() const;
 
        virtual void GetConfigList(utils::bat::DbVector& cfg_list, std::string prefix) const;
 
        std::string GetCfgFile() const;
 
        std::string GetCfgAsString() const;
 
 
        virtual void SetSimulateFlag(const bool flag);
 
        virtual void SetIgnoreFlag(const bool flag);
 
        virtual bool GetIgnored() const;
 
        virtual bool GetSimulated() const;
 
       virtual std::string GetMapFile() const;
 
        void CheckConfig() const;
 
      protected:
        void MergeConfig(const elt::configng::CiiConfigDocument &doc, bool check=true);
 
 
 
        bool GetVariantValue(const elt::configng::CiiConfigInstanceNode node,
                                           protocol::base::Variant& value) const;
 
        bool IsValidNodeIDFormat(const std::string& nodeIdString) const;
 
      protected:
        // All configuration parameters related to the LCS are stored in
        // dedicated STL maps to make them easilly accessible when downloading
        // the configuration to the LCS.
 
        std::string         m_filename;    
        std::string         m_name;        
        std::string         m_identifier;  
        std::string         m_type;        
        std::string         m_fits_prefix;
        bool                m_simulated;
        bool                m_ignored;
        std::string         m_lcs_prefix;
        std::string         m_address;
        std::string         m_sim_address;
        std::string         m_map_file;
        std::string         m_alias;
        int                 m_lcs_namespace;
 
        std::unique_ptr<elt::configng::CiiConfigDocument> m_config_doc;
 
      private:
        log4cplus::Logger   m_logger;
 
      };
 
    }
  }
}
 
 
#endif //FCF_DEVMGR_COMMON_DEVICECONFIG_HPP_