config.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2020-2025 European Southern Observatory (ESO)
//
// SPDX-License-Identifier: LGPL-3.0-only
 
#ifndef HLCC_LSVSIM_CONFIG_HPP
#define HLCC_LSVSIM_CONFIG_HPP
 
#include <rad/config.hpp>
#include "lsvsim/logger.hpp"
 
namespace hlcc::lsvsim {
/*
 * Struct representing a state variable description
 * with the state variable name and associated
 * state variable type script to be used.
 */
struct SvDescription {
    std::string sv_name;
    std::string sv_type;
};
 
}// namespace hlcc::lsvsim
 
namespace elt::configng {
 
// Implementation of converter between hlcc::lsvsim::SvDescription and CiiConfigInstanceNode hierarchy
// Decode method: Extract node values into hlcc::lsvsim::SvDescription
// Encode method: construct nodes from values of hlcc::lsvsim::SvDescription
template<>
struct CiiConfigValueConverter<hlcc::lsvsim::SvDescription, CiiConfigInstanceNode> {
  static bool Decode(const CiiConfigInstanceNode& node, hlcc::lsvsim::SvDescription &target) {
    if (node.GetKind() != CiiConfigNodeKind::MAP || node.GetDataTypeName() != "SvDescription") {
      std::cerr << "Conversion to SvDescription not possible" << std::endl;
      return false;
    }
    target.sv_name = node["sv_name"].As<std::string>();
    target.sv_type = node["sv_type"].As<std::string>();
    return true;
  }
 
  static bool Encode(CiiConfigInstanceNode &node, const hlcc::lsvsim::SvDescription &source) {
    if (node.GetKind() != elt::configng::CiiConfigNodeKind::MAP) {
      return false;
    }
    node.Set("sv_name", elt::configng::CiiConfigInstanceNode::From(source.sv_name));
    node.Set("sv_type", elt::configng::CiiConfigInstanceNode::From(source.sv_type));
    return true;
  }
};
 
} // namespace elt::configng
 
namespace hlcc::lsvsim {
 
const std::string KEY_CONFIG_PUB_DDS_PROFILE            = "cfg/pub/dds/profile";
const std::string KEY_CONFIG_PUB_DDS_NIC                = "cfg/pub/dds/nic";
const std::string KEY_CONFIG_PUB_DDS_FILE               = "cfg/pub/dds/file";
const std::string KEY_CONFIG_PUB_DDS_DOMAIN_ID_HLCC     = "cfg/pub/dds/domain_id_hlcc";
const std::string KEY_CONFIG_PUB_DDS_DOMAIN_ID_CCS_INS  = "cfg/pub/dds/domain_id_ccs_ins";
const std::string KEY_CONFIG_PUB_DDS_DOMAIN_ID_GENERAL  = "cfg/pub/dds/domain_id_general";
const std::string KEY_CONFIG_SIM_ACTIVITY_PERIOD_MS     = "cfg/sim_activity_period_ms";
const std::string KEY_CONFIG_SV_LIST                    = "cfg/sv_list";
const std::string KEY_CONFIG_SV_SPECIFIC_CONFIG         = "cfg/sv_specific_config";
const std::string HEARTBEAT("mon/heartbeat");
 
 
const std::vector<std::string> OLDB_CFG_KEYS_STRING = {
    KEY_CONFIG_PUB_DDS_PROFILE             ,
    KEY_CONFIG_PUB_DDS_NIC                 ,
    KEY_CONFIG_PUB_DDS_FILE                ,
    KEY_CONFIG_SV_SPECIFIC_CONFIG
};
 
const std::vector<std::string> OLDB_CFG_KEYS_UINT32 = {
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_HLCC      ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_CCS_INS   ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_GENERAL   ,
    KEY_CONFIG_SIM_ACTIVITY_PERIOD_MS
};
 
const std::string CONFIG_DEFAULT_VERSION                    = std::string(VERSION);
const std::string CONFIG_DEFAULT_MODNAME                    = "hlccLsvsim";
const std::string CONFIG_DEFAULT_PROCNAME                   = "lsvsim";
const std::string CONFIG_DEFAULT_FILENAME                   = "config/lsvsim/config.yaml";
const std::string CONFIG_DEFAULT_SCXML_FILENAME             = "config/lsvsim/sm_radapp_default.xml";
const std::string CONFIG_DEFAULT_SCXML_APPEND               = "config/lsvsim/sm.xml";
const std::string CONFIG_DEFAULT_LOG_LEVEL                  = "INFO";
const std::string CONFIG_DEFAULT_LOG_PROPERTIES             = "config/lsvsim/log.properties";
const std::string CONFIG_DEFAULT_REQ_ENDPOINT               = "zpb.rr://127.0.0.1:11008/";
const std::string CONFIG_DEFAULT_OLDB_URI_PREFIX            = "cii.oldb:///elt/tel";
const int CONFIG_DEFAULT_OLDB_CONN_TIMEOUT                  = 2;  // sec
const int CONFIG_DEFAULT_OLDB_ASYNC_PERIOD                  = 0;  // ms; we currently do not use RAD async OLDB writes, but still configure all standard attributes.
const bool CONFIG_DEFAULT_TRS_HEALTH_ENABLED                = false;
 
const std::string CONFIG_DEFAULT_PUB_DDS_PROFILE            = ""; // default: use ccs default profile
const std::string CONFIG_DEFAULT_PUB_DDS_NIC                = "";
const std::string CONFIG_DEFAULT_PUB_DDS_FILE               = "";
const uint32_t CONFIG_DEFAULT_PUB_DDS_DOMAIN_ID_HLCC        = 3;
const uint32_t CONFIG_DEFAULT_PUB_DDS_DOMAIN_ID_CCS_INS     = 2;
const uint32_t CONFIG_DEFAULT_PUB_DDS_DOMAIN_ID_GENERAL     = 1;
const uint32_t CONFIG_DEFAULT_SIM_ACTIVITY_PERIOD_MS        = 1000;
const std::vector<SvDescription> CONFIG_DEFAULT_SV_LIST     = {};
const std::string CONFIG_DEFAULT_SV_SPECIFIC_CONFIG         = "";
 
/*
 * Struct packing all configuration parameters
 */
struct ConfigPack {
    std::string modname;
    std::string procname;
    std::string filename;
    std::string sm_scxml;
    std::string sm_append;
    std::string log_level;
    std::string log_properties;
    std::string req_endpoint;
    std::string oldb_uri_prefix;
    int conn_timeout;
    int oldb_async_period;
    std::vector<SvDescription> sv_list;
    uint32_t sim_activity_period_ms;
    std::string sv_specific_config;
    std::string pub_dds_profile;
    std::string pub_dds_nic;
    std::string pub_dds_file;
    std::uint32_t pub_dds_domain_id_hlcc;
    std::uint32_t pub_dds_domain_id_ccs_ins;
    std::uint32_t pub_dds_domain_id_general;
};
 
class Config : public rad::Config {
 public:
    Config();
 
    virtual ~Config();
 
    ConfigPack GetConfigPack();
 
    Config(const Config&) = delete;              
    Config& operator=(const Config&) = delete;  
};
 
}  // namespace hlcc::lsvsim
 
#endif  // HLCC_LSVSIM_CONFIG_HPP