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_TELMON_CONFIG_HPP
#define HLCC_TELIF_TELMON_CONFIG_HPP
 
#include <string>
#include <config-ng/ciiConfigApi.hpp>
#include <rad/config.hpp>
 
#include "telmon/logger.hpp"
 
 
namespace hlcc::telmon {
 
/* 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 MonitoredApp {
  std::string name;
  std::string oldb;
  std::string stdcmds;
  std::string pubsub;
  bool ignore;
};
 
struct MonitoredSubsystem {
  std::string name;
  bool ignore_subsystem;
  std::vector<MonitoredApp> monitored_apps;
};
 
} // namespace hlcc::telmon
 
namespace elt::configng {
 
// Implementation of converter between hlcc::telmon::MonitoredApp and CiiConfigInstanceNode hierarchy
// Decode method: Extract node values into hlcc::telmon::MonitoredApp
// Encode method: construct nodes from values of hlcc::telmon::MonitoredApp
 
 
template<>
struct CiiConfigValueConverter<hlcc::telmon::MonitoredSubsystem, CiiConfigInstanceNode> {
    static bool Decode(const CiiConfigInstanceNode& node, hlcc::telmon::MonitoredSubsystem &target) {
    if (node.GetKind() != CiiConfigNodeKind::MAP || node.GetDataTypeName() != "MonitoredSubsystem") {
        std::cerr  << node.GetDataTypeName()  << "Conversion to MonitoredSubsystem not possible" << std::endl;
        return false;
    }
    target.name = node["name"].As<std::string>();
    target.ignore_subsystem = node["ignore_subsystem"].As<bool>();
    Decode(node, target.monitored_apps);
    return true;
    }
 
    static bool Decode(const CiiConfigInstanceNode& node, std::vector<hlcc::telmon::MonitoredApp> &targets) {
        if (node.GetKind() != CiiConfigNodeKind::MAP || node.GetDataTypeName() != "MonitoredSubsystem") {
            std::cerr << "Conversion to MonitoredApp not possible" << std::endl;
            return false;
        }
 
        for (size_t i = 0; i < node["monitored_apps"].GetSize(); i++ ){
            auto temp = node["monitored_apps"].Get(i);
            hlcc::telmon::MonitoredApp mon_temp;
 
            mon_temp.name = temp["name"].As<std::string>();
            mon_temp.ignore = temp["ignore"].As<bool>();
            mon_temp.oldb = temp["oldb"].As<std::string>();
            mon_temp.pubsub = temp["pubsub"].As<std::string>();
            mon_temp.stdcmds = temp["stdcmds"].As<std::string>();
 
            targets.push_back(mon_temp);
        }
        return true;
    }
 
    static bool Encode(CiiConfigInstanceNode &node, const hlcc::telmon::MonitoredSubsystem &source) {
 
        if (node.GetKind() != elt::configng::CiiConfigNodeKind::MAP) {
            std::cerr << "Conversion from MonitoredSubsystem not possible" << std::endl;
            return false;
        }
        node.Set("name"    , elt::configng::CiiConfigInstanceNode::From(source.name));
        node.Set("ignore_subsystem"    , elt::configng::CiiConfigInstanceNode::From(source.ignore_subsystem));
        Encode(node, source.monitored_apps);
        return true;
    }
 
    static bool Encode(CiiConfigInstanceNode &node, const std::vector<hlcc::telmon::MonitoredApp> &source) {
 
        if (node.GetKind() != elt::configng::CiiConfigNodeKind::MAP) {
            std::cerr << "Conversion from MonitoredApp not possible" << std::endl;
            return false;
        }
        CiiConfigInstanceNode temp_node = CiiConfigInstanceNode(CiiConfigNodeKind::MAP);
        for (auto item : source){
 
            temp_node.Set("name"    , elt::configng::CiiConfigInstanceNode::From(item.name));
            temp_node.Set("oldb"    , elt::configng::CiiConfigInstanceNode::From(item.oldb));
            temp_node.Set("stdcmds" , elt::configng::CiiConfigInstanceNode::From(item.stdcmds));
            temp_node.Set("pubsub"  , elt::configng::CiiConfigInstanceNode::From(item.pubsub));
            temp_node.Set("ignore"  , elt::configng::CiiConfigInstanceNode::From(item.ignore));
            node["monitored_apps"].PushBack(temp_node.Clone());
        }
        return true;
    }
};
}// namespace elt::configng
namespace hlcc::telmon {
 
const char CONFIG_KEY_SEPARATOR_OLDB = '/';
// const char KEY_SEPARATOR_CFG = '.';
// const std::string CONFIG_ROOT_NODE = "app";
 
/* Type of the configuration parameters */
enum ConfigType { CFG_STRING, CFG_DOUBLE, CFG_UINT16, CFG_UINT32, CFG_VEC_STRING, CFG_MONITORED_SUBSYSTEMS };
 
/*
 * 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_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_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_ESTIMATION_PERIOD_MS         = KEY_CONFIG + "estimation_period_ms";
const std::string KEY_CONFIG_READYFORHANDOVER_INERTIA_MS  = KEY_CONFIG + "ready_for_handover_inertia_ms";
const std::string KEY_CONFIG_ESTIMATIONSCRIPTS            = KEY_CONFIG + "estim_scripts";
const std::string KEY_CONFIG_MONITORED_SUBSYSTEMS         = KEY_CONFIG + "monitored_subsystems";
const std::string KEY_CONFIG_NIGHT_TIME_NEEDED_SUBSYS     = KEY_CONFIG + "night_time_cfg/needed_subsystems";
const std::string KEY_CONFIG_NIGHT_TIME_NOT_NEEDED_SUBSYS = KEY_CONFIG + "night_time_cfg/not_needed_subsystems";
const std::string KEY_CONFIG_NIGHT_TIME_NOT_NEEDED_CRITICAL_SUBSYS= KEY_CONFIG + "night_time_cfg/not_needed_critical_subsystems";
 
/*
 * 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_PUB_DDS_PROFILE                       ,
    KEY_CONFIG_PUB_DDS_NIC                           ,
    KEY_CONFIG_PUB_DDS_FILE
};
 
const std::vector<std::string> OLDB_CFG_KEYS_VECTOR_STRING = {
    KEY_CONFIG_ESTIMATIONSCRIPTS                     ,
    KEY_CONFIG_NIGHT_TIME_NEEDED_SUBSYS              ,
    KEY_CONFIG_NIGHT_TIME_NOT_NEEDED_SUBSYS          ,
    KEY_CONFIG_NIGHT_TIME_NOT_NEEDED_CRITICAL_SUBSYS
};
 
const std::vector<std::string> OLDB_CFG_KEYS_UINT32 = {
    KEY_CONFIG_ESTIMATION_PERIOD_MS                  ,
    KEY_CONFIG_READYFORHANDOVER_INERTIA_MS           ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_HLCC                ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_CCS_INS             ,
    KEY_CONFIG_PUB_DDS_DOMAIN_ID_GENERAL
};
 
 

const std::string CONFIG_DEFAULT_VERSION                    = std::string(VERSION);
const std::string CONFIG_DEFAULT_MODNAME                    = "telmon";
const std::string CONFIG_DEFAULT_PROCNAME                   = "telmon";
const std::string CONFIG_DEFAULT_FILENAME                   = "config/telmon/definitions.yaml";
const std::string CONFIG_DEFAULT_SCXML_FILENAME             = "telmon/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/telmon/log.properties";
const std::string CONFIG_DEFAULT_REQ_ENDPOINT               = "zpb.rr://127.0.0.1:11003/"; // the potentially unsafe zpb.rr://0.0.0.0:11003/ we use only in the yaml file.
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::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 uint32_t CONFIG_DEFAULT_ESTIMATION_PERIOD_MS       = 1000;
const uint32_t CONFIG_DEFAULT_READYFORHANDOVER_INERTIA_MS= 850;
const std::vector<std::string> CONFIG_DEFAULT_ESTIMATIONSCRIPTS  = {"MonScripts.ReadyForHandoverEstimation", "MonScripts.CcsStateEstimation"};
const std::vector<MonitoredSubsystem> CONFIG_DEFAULT_MONITORED_SUBSYSTEMS  = {};
const std::vector<std::string> CONFIG_DEFAULT_NIGHT_TIME_NEEDED = {"eltpk", "telif", "telmon"};
const std::vector<std::string> CONFIG_DEFAULT_NIGHT_TIME_NOT_NEEDED      = {"m2psest", "m2whest", "m3psest", "m3whest"};
const std::vector<std::string> CONFIG_DEFAULT_NIGHT_TIME_NOT_NEEDED_CRITICAL = {"segexmgr"};
 
/*
 * Struct packing all configuration parameters
 */
struct ConfigPack {
    std::string version;
    std::string modname;
    std::string procname;
    std::string filename;
    std::string sm_scxml;
    std::string sm_scxml_append;
    std::string log_level;
    std::string log_properties;
    std::string req_endpoint;
    std::string oldb_uri_prefix;
    int oldb_con_timeout;
    bool trs_health_enabled;
    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;
    std::uint16_t estimation_period_ms;
    std::uint16_t readyforhandover_inertia_ms;
    std::vector<std::string> estimation_scripts;
    std::vector<MonitoredSubsystem> monitored_subsystems;
    std::vector<std::string> night_time_needed_subsystems;
    std::vector<std::string> night_time_not_needed_subsystems;
    std::vector<std::string> night_time_not_needed_critical_subsystems;
};

class Config : public rad::Config {
 public:
    Config();

    virtual ~Config();

    ConfigPack GetConfigPack();
 
    Config(const Config&) = delete;              
    Config& operator=(const Config&) = delete;  
 
};
 
}  // namespace hlcc::telmon
 
#endif  // HLCC_TELIF_TELMON_CONFIG_HPP