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_TELIF_TELIF_CONFIG_HPP
#define HLCC_TELIF_TELIF_CONFIG_HPP
 
#include <string>
#include <config-ng/ciiConfigApi.hpp>
#include <rad/config.hpp>
 
#include "telif/logger.hpp"
 
 
namespace hlcc::telif {
 
/* hlcc config error class */
class ConfigError : public std::runtime_error {
public:
    explicit ConfigError(const std::string& message)
        : std::runtime_error(message)
    {}
};
 
/*
 * Type for the Telescope named position
 * which will assign a name to an
 * alt/az position.
 */
struct TelNamedPosition {
  std::string pos_string;
  double alt_pos;
  double az_pos;
};
struct LsvApp {
  std::string name;
  std::string oldb;
  std::string cmds;
};
} // namespace hlcc::telif
 
namespace elt::configng {
 
// Implementation of converter between hlcc::telif::TelNamedPosition and CiiConfigInstanceNode hirearchy
// Decode method: Extract node values into hlcc::telif::TelNamedPosition
// Encode method: construct nodes from values of hlcc::telif::TelNamedPosition
template<>
struct CiiConfigValueConverter<hlcc::telif::TelNamedPosition, CiiConfigInstanceNode> {
  static bool Decode(const CiiConfigInstanceNode& node, hlcc::telif::TelNamedPosition &target) {
    if (node.GetKind() != CiiConfigNodeKind::MAP || node.GetDataTypeName() != "TelNamedPosition") {
      std::cerr << "Conversion to TelNamedPosition not possible" << std::endl;
      return false;
    }
    target.pos_string = node["pos_string"].As<std::string>();
    target.alt_pos = node["alt_pos"].As<double>();
    target.az_pos = node["az_pos"].As<double>();
    return true;
  }
 
  static bool Encode(CiiConfigInstanceNode &node, const hlcc::telif::TelNamedPosition &source) {
    if (node.GetKind() != elt::configng::CiiConfigNodeKind::MAP) {
      return false;
    }
    node.Set("pos_string", elt::configng::CiiConfigInstanceNode::From(source.pos_string));
    node.Set("alt_pos", elt::configng::CiiConfigInstanceNode::From(source.alt_pos));
    node.Set("az_pos", elt::configng::CiiConfigInstanceNode::From(source.az_pos));
    return true;
  }
};
 
// Implementation of converter between hlcc::telif::LsvApp and CiiConfigInstanceNode hierarchy
// Decode method: Extract node values into hlcc::telif::LsvApp
// Encode method: construct nodes from values of hlcc::telif::LsvApp
template<>
struct CiiConfigValueConverter<hlcc::telif::LsvApp, CiiConfigInstanceNode> {
  static bool Decode(const CiiConfigInstanceNode& node, hlcc::telif::LsvApp &target) {
    if (node.GetKind() != CiiConfigNodeKind::MAP || node.GetDataTypeName() != "LsvApp") {
      std::cerr << "Conversion to LsvApp not possible" << std::endl;
      return false;
    }
    target.name = node["name"].As<std::string>();
    target.oldb = node["oldb"].As<std::string>();
    target.cmds = node["cmds"].As<std::string>();
    return true;
  }
 
  static bool Encode(CiiConfigInstanceNode &node, const hlcc::telif::LsvApp &source) {
    if (node.GetKind() != elt::configng::CiiConfigNodeKind::MAP) {
      return false;
    }
    node.Set("name", elt::configng::CiiConfigInstanceNode::From(source.name));
    node.Set("oldb", elt::configng::CiiConfigInstanceNode::From(source.oldb));
    node.Set("cmds", elt::configng::CiiConfigInstanceNode::From(source.cmds));
    return true;
  }
};
 
} // namespace elt::configng
 
namespace hlcc::telif {
 
const char CONFIG_KEY_SEPARATOR_OLDB = '/';
// const char KEY_SEPARATOR_CFG = '.';
// const std::string CONFIG_ROOT_NODE = "app";
 
 
/*
 * Configuration OLDB Attributes.
 * Note that CII OLDB convert all keys to lowercase.
 *
 * The following definitions are handled in rad/cpp/app/src/include/rad/config.hpp
 * const std::string KEY_CONFIG = "cfg";
 * const std::string KEY_CONFIG_VERSION                     = KEY_CONFIG + "version";
 * const std::string KEY_CONFIG_MODNAME                     = KEY_CONFIG + "/" + "modname";
 * const std::string KEY_CONFIG_PROCNAME                    = KEY_CONFIG + "/" + "procname";
 * const std::string KEY_CONFIG_FILENAME                    = KEY_CONFIG + "/" + "filename";
 * const std::string KEY_CONFIG_LOG_LEVEL                   = KEY_CONFIG + "/" + "log_level";
 * const std::string KEY_CONFIG_LOG_PROPERTIES              = KEY_CONFIG + "/" + "log_properties";
 * const std::string KEY_CONFIG_SM_SCXML                    = KEY_CONFIG + "/" + "sm_scxml";
 * const std::string KEY_CONFIG_SM_APPEND                   = KEY_CONFIG + "sm_scxml_append";
 * const std::string KEY_CONFIG_REQ_ENDPOINT                = KEY_CONFIG + "/" + "req_endpoint"; *
 * const std::string KEY_CONFIG_OLDB_URI_PREFIX             = KEY_CONFIG + "/" + "oldb_uri_prefix";
 * const std::string KEY_CONFIG_OLDB_CONN_TIMEOUT           = KEY_CONFIG + "oldb_conn_timeout";
 * const std::string KEY_CONFIG_OLDB_ASYNC_PERIOD           = KEY_CONFIG + "oldb_async_period";
 * const std::string KEY_CONFIG_TRS_HEALTH_ENABLED          = KEY_CONFIG + "trs_health_enabled";
 */
 
const std::string KEY_CONFIG                             = rad::KEY_CONFIG;
const std::string KEY_CONFIG_REQ_ELTPK                   = KEY_CONFIG + "req_eltpk";
const std::string KEY_CONFIG_REQ_TREX                    = KEY_CONFIG + "req_trex";
const std::string KEY_CONFIG_LSVS                        = KEY_CONFIG + "lsvs";
const std::string KEY_CONFIG_TRSHKS_CMDS                 = KEY_CONFIG + "trs-hks/cmds";
 
const std::string KEY_CONFIG_PUB_DDS_PROFILE             = KEY_CONFIG + "pub/dds/profile";
const std::string KEY_CONFIG_PUB_DDS_NIC                 = KEY_CONFIG + "pub/dds/nic";
const std::string KEY_CONFIG_PUB_DDS_FILE                = KEY_CONFIG + "pub/dds/file";
const std::string KEY_CONFIG_PUB_DDS_DOMAIN_ID_HLCC      = KEY_CONFIG + "pub/dds/domain_id_hlcc";
const std::string KEY_CONFIG_PUB_DDS_DOMAIN_ID_CCS_INS   = KEY_CONFIG + "pub/dds/domain_id_ccs_ins";
const std::string KEY_CONFIG_PUB_DDS_DOMAIN_ID_GENERAL   = KEY_CONFIG + "pub/dds/domain_id_general";
const std::string KEY_CONFIG_ALTAZ_ALT_UPPER_LIMIT_OP    = KEY_CONFIG + "altaz/alt_upper_limit_op";
const std::string KEY_CONFIG_ALTAZ_ALT_LOWER_LIMIT_OP    = KEY_CONFIG + "altaz/alt_lower_limit_op";
const std::string KEY_CONFIG_ALTAZ_AZ_UPPER_LIMIT_OP     = KEY_CONFIG + "altaz/az_upper_limit_op";
const std::string KEY_CONFIG_ALTAZ_AZ_LOWER_LIMIT_OP     = KEY_CONFIG + "altaz/az_lower_limit_op";
const std::string KEY_CONFIG_ALTAZ_ALT_UPPER_LIMIT_FCT   = KEY_CONFIG + "altaz/alt_upper_limit_fct";
const std::string KEY_CONFIG_ALTAZ_ALT_LOWER_LIMIT_FCT   = KEY_CONFIG + "altaz/alt_lower_limit_fct";
const std::string KEY_CONFIG_ALTAZ_AZ_UPPER_LIMIT_FCT    = KEY_CONFIG + "altaz/az_upper_limit_fct";
const std::string KEY_CONFIG_ALTAZ_AZ_LOWER_LIMIT_FCT    = KEY_CONFIG + "altaz/az_lower_limit_fct";
const std::string KEY_CONFIG_ROUS_TIMER_PERIOD_S         = KEY_CONFIG + "rous/timer_period_s";
const std::string KEY_CONFIG_READY_FOR_HANDOVER_ESTIMATION_PERIOD_MS
                                        = KEY_CONFIG + "ready_for_handover/estimation_period_ms";
const std::string KEY_CONFIG_NAMED_POS                   = KEY_CONFIG + "tel_named_pos";
const std::string KEY_CONFIG_RTCTK_CCSSIM_UPD_IP         = KEY_CONFIG + "rtctk_ccssim/udp_ip";
const std::string KEY_CONFIG_RTCTK_CCSSIM_UPD_PORT       = KEY_CONFIG + "rtctk_ccssim/udp_port";
const std::string KEY_CONFIG_GS_TO_GP_MAPPING            = KEY_CONFIG + "gs_to_gp_mapping";
 
/*
 * Map containing all the configuration paramenters to be configured
 * in the Oldb and also the type  that shoudl be used to publish.
 */
const std::vector<std::string> OLDB_CFG_KEYS_STRING = {
    KEY_CONFIG_REQ_ELTPK                               ,
    KEY_CONFIG_REQ_TREX                                ,
    KEY_CONFIG_PUB_DDS_PROFILE                         ,
    KEY_CONFIG_PUB_DDS_NIC                             ,
    KEY_CONFIG_PUB_DDS_FILE                            ,
    KEY_CONFIG_RTCTK_CCSSIM_UPD_IP
};
 
const std::vector<std::string> OLDB_CFG_KEYS_UINT32 = {
    KEY_CONFIG_READY_FOR_HANDOVER_ESTIMATION_PERIOD_MS ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_HLCC                  ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_CCS_INS               ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_GENERAL               ,
    KEY_CONFIG_ROUS_TIMER_PERIOD_S                     ,
    KEY_CONFIG_RTCTK_CCSSIM_UPD_PORT
};
 
const std::vector<std::string> OLDB_CFG_KEYS_DOUBLE= {
    KEY_CONFIG_ALTAZ_ALT_UPPER_LIMIT_OP                ,
    KEY_CONFIG_ALTAZ_ALT_LOWER_LIMIT_OP                ,
    KEY_CONFIG_ALTAZ_AZ_UPPER_LIMIT_OP                 ,
    KEY_CONFIG_ALTAZ_AZ_LOWER_LIMIT_OP                 ,
    KEY_CONFIG_ALTAZ_ALT_UPPER_LIMIT_FCT               ,
    KEY_CONFIG_ALTAZ_ALT_LOWER_LIMIT_FCT               ,
    KEY_CONFIG_ALTAZ_AZ_UPPER_LIMIT_FCT                ,
    KEY_CONFIG_ALTAZ_AZ_LOWER_LIMIT_FCT
};

const std::string CONFIG_DEFAULT_VERSION                    = std::string(VERSION);
const std::string CONFIG_DEFAULT_MODNAME                    = "telif";
const std::string CONFIG_DEFAULT_PROCNAME                   = "telif";
const std::string CONFIG_DEFAULT_FILENAME                   = "config/telif/definitions.yaml";
const std::string CONFIG_DEFAULT_SCXML_FILENAME             = "telif/sm.xml";
const std::string CONFIG_DEFAULT_SCXML_APPEND               = "";
const std::string CONFIG_DEFAULT_LOG_LEVEL                  = "INFO";
const std::string CONFIG_DEFAULT_LOG_PROPERTIES             = "config/telif/log.properties";
const std::string CONFIG_DEFAULT_REQ_ENDPOINT               = "zpb.rr://127.0.0.1:12081/"; // the potentially unsafe zpb.rr://0.0.0.0:12081/ we use only in the yaml file.
const std::string CONFIG_DEFAULT_REQ_ELTPK                  = "zpb.rr://localhost:11002/";
const std::string CONFIG_DEFAULT_REQ_TREX                   = "zpb.rr://localhost:14001/";
const std::string CONFIG_DEFAULT_OLDB_URI_PREFIX            = "cii.oldb:///elt/cs/hlcc/";
const uint32_t CONFIG_DEFAULT_OLDB_CONN_TIMEOUT             = 1;  // sec
const uint32_t 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::vector<LsvApp> CONFIG_DEFAULT_LSVS               = {}; //[{name: \"msTrackCtr\", oldb: \"cii.oldb:///elt/tel/ms/lsv/trackctr\", stdcmds: \"zpb.rr://localhost:11001/TrackCmds\"}]";
 
const std::string CONFIG_DEFAULT_PUB_DDS_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 double CONFIG_DEFAULT_ALTAZ_ALT_UPPER_LIMIT_OP   = 1.544616;  // radians - double
const double CONFIG_DEFAULT_ALTAZ_ALT_LOWER_LIMIT_OP   = 0.349066;  // radians - double
const double CONFIG_DEFAULT_ALTAZ_AZ_UPPER_LIMIT_OP    = 6.283185;  // radians - double
const double CONFIG_DEFAULT_ALTAZ_AZ_LOWER_LIMIT_OP    = -3.141593; // radians - double
const double CONFIG_DEFAULT_ALTAZ_ALT_UPPER_LIMIT_FCT  = 1.570796;  // radians - double
const double CONFIG_DEFAULT_ALTAZ_ALT_LOWER_LIMIT_FCT  = 0.0;       // radians - double
const double CONFIG_DEFAULT_ALTAZ_AZ_UPPER_LIMIT_FCT   = 6.283185;  // radians - double
const double CONFIG_DEFAULT_ALTAZ_AZ_LOWER_LIMIT_FCT   = -3.141593; // radians - double
const double CONFIG_DEFAULT_ROUS_TIMER_PERIOD_S        = 300;      // seconds
const uint32_t CONFIG_DEFAULT_READY_FOR_HANDOVER_ESTIMATION_PERIOD_MS = 1000; // milliseconds
 
const TelNamedPosition park = {.pos_string = "PARK", .alt_pos = 0.0, .az_pos = 0.0};
const TelNamedPosition zenith = {.pos_string = "ZENITH", .alt_pos = 1.570796, .az_pos = 0.0};
const std::vector<TelNamedPosition> CONFIG_DEFAULT_CONFIG_NAMED_POS  = {park, zenith};
 
const std::string CONFIG_DEFAULT_RTCTK_CCSSIM_UDP_IP = "127.0.0.1";
const uint32_t CONFIG_DEFAULT_RTCTK_CCSSIM_UDP_PORT = 61187;
const std::vector<std::string> CONFIG_DEFAULT_GS_TO_GP_MAPPING = {"A", "B", "C"};
class Config : public rad::Config {
 public:
    Config();

    virtual ~Config();
 
    Config(const Config&) = delete;              
    Config& operator=(const Config&) = delete;  
};
 
}  // namespace hlcc::telif
 
#endif  // HLCC_TELIF_TELIF_CONFIG_HPP