config.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup server
 * @copyright ESO - European Southern Observatory
 * @author
 *
 * @brief Config class header file.
 */
#ifndef SERVER_CONFIG_HPP_
#define SERVER_CONFIG_HPP_
 
#include <chrono>
#include <optional>
#include <string>
 
#include <rad/config.hpp>
 
#include <daq/config/manager.hpp>
#include <daq/dpmClient.hpp>
 
namespace server {
 
/**
 * Rad configuration keys
 */
const std::string KEY_CONFIG_PUB_ENDPOINT = rad::KEY_CONFIG + "pub_endpoint";
const std::string KEY_CONFIG_INSTRUMENT_ID = rad::KEY_CONFIG + "instrument_id";
const std::string KEY_CONFIG_DATAROOT = rad::KEY_CONFIG + "dataroot";
const std::string KEY_CONFIG_WORKSPACE = rad::KEY_CONFIG + "daq/workspace";
const std::string KEY_CONFIG_STALE_DAQ_ACQUIRING = rad::KEY_CONFIG + "daq/stale_acquiring_hours";
const std::string KEY_CONFIG_STALE_DAQ_MERGING = rad::KEY_CONFIG + "daq/stale_merging_hours";
const std::string KEY_CONFIG_DICTIONARIES = rad::KEY_CONFIG + "dictionaries";
 
const std::string KEY_CONFIG_DPM_REQ_ENDPOINT = rad::KEY_CONFIG + "dpm/req_endpoint";
const std::string KEY_CONFIG_DPM_PUB_ENDPOINT = rad::KEY_CONFIG + "dpm/pub_endpoint";
const std::string KEY_CONFIG_DPM_TIMEOUT_SEC = rad::KEY_CONFIG + "dpm/timeout_sec";
 
/**
 * Default application configuration values.
 */
const std::string CONFIG_DEFAULT_PROCNAME = "ocm";
const std::string CONFIG_DEFAULT_FILENAME = "config/daqOcmServer/config.yaml";
const std::string CONFIG_DEFAULT_WORKSPACE = "ocm";
const std::string CONFIG_DEFAULT_SCXML_FILENAME = "config/daqOcmServer/sm.xml";
const std::string CONFIG_DEFAULT_LOG_LEVEL = "WARN";
const int CONFIG_DEFAULT_DB_TIMEOUT_SEC = 2;
const std::string CONFIG_DEFAULT_REQ_ENDPOINT = "zpb.rr://127.0.0.1:12081/";
const std::string CONFIG_DEFAULT_PUB_ENDPOINT = "zpb.ps://127.0.0.1:12082/";
const std::string CONFIG_DEFAULT_OLDB_URI_PREFIX = "cii.oldb:/elt";
const int CONFIG_DEFAULT_OLDB_CONN_TIMEOUT = 2;
 
/**
 * Application configuration environment variables
 */
const std::string CONFIG_ENVVAR_OUT_PATH = "DATAROOT";
 
/**
 * This class provide access to the command line options and
 * the configuration parameters stored in the configuration file.
 */
class Config {
public:
    /**
     * Default constructor.
     *
     * Initialize application configuration attributes by
     * - first use the default constant values defined in the header
     * - override the constant values with environment variables (if defined)
     */
    Config();
 
    Config(const Config &) = delete;             //! Disable copy constructor
    Config &operator=(const Config &) = delete;  //! Disable assignment operator
 
    /**
     * This method parses the command line parameters overriding
     * the initialization done in the constructor.
     *
     * @param[in] argc Number of command line options.
     * @param[in] argv Pointer to the array of command line options.
     * @return false if the help option has been invoked, true otherwise.
     */
    bool ParseOptions(int argc, char *argv[]);
 
    /**
     * This method load from a configuration file the application
     * configuration overriding the initialization done in the constructor
     * and the command line options.
     *
     * @param[in] filename Application configuration filename.
     */
    void LoadConfig(const std::string &filename = "");
 
    /**
     * @return The network endpoint to send request to this application.
     * The format is "<middleware>.<protocol>://<ipaddr>:<port>".
     * For example: "zpb.rr://127.0.0.1:12081/"
     */
    const std::string &GetMsgReplierEndpoint() const;
 
    /**
     * @return The network endpoint used to publish topics from this application.
     * The format is "<middleware>.<protocol>://<ipaddr>:<port>".
     * For example: "zpb.ps://127.0.0.1:12082/"
     */
    const std::string &GetPubEndpoint() const;
 
    /**
     * @return The DB key prefix and port used to connect to the runtime DB.
     */
    const std::string &GetDbPrefix() const;
 
    /**
     * @return The timeout used when communicating to the runtime DB.
     */
    std::chrono::seconds GetDbTimeout() const;
 
    /**
     * @return The SCXML State Machine model filename used by the application.
     */
    const std::string &GetSmScxmlFilename() const;
 
    /**
     * @return The application configuration filename.
     */
    const std::string &GetConfigFilename() const;
 
    /**
     * @return The application process name.
     */
    const std::string &GetProcName() const;
 
    /**
     * @return The configured log level.
     */
    const std::string &GetLogLevel() const;
 
    /**
     * @return The log properties config filename.
     */
    const std::string &GetLogProperties() const;
 
    /**
     * @return List of keyword dictionaries.
     */
    std::vector<std::string> const& GetDictionaryNames() const;
 
    /**
     * @return Workspace root (absolute path)
     */
    std::filesystem::path GetWorkspace() const {
        if (m_workspace.is_relative()) {
            return m_out_path / m_workspace;
        }
        return m_workspace;
    }
    daq::config::Manager &GetMgr() {
        return m_mgr;
    }
    daq::DpmClientParams const &GetDpmClientParams() const;
 
    daq::config::Manager m_mgr;
    // We must delay initialization until logging has been configured, otherwise it spams
    // the log.
    std::optional<elt::configng::CiiConfigDocument> m_config;
 
    std::string m_proc_name;
    std::string m_instrument_id;
    std::string m_log_level;
    std::string m_log_properties;
    std::string m_config_filename;
    std::string m_scxml_filename;
    std::string m_db_prefix;
    int m_db_timeout_sec;
    std::string m_req_endpoint;
    std::string m_pub_endpoint;
    std::string m_out_path;
    std::filesystem::path m_workspace;
    daq::DpmClientParams m_dpm_params;
    std::chrono::hours m_stale_acquiring = std::chrono::hours(14);
    std::chrono::hours m_stale_merging = std::chrono::hours(2 * 24);
    std::vector<std::string> m_dictionary_names;
};
 
}  // namespace server
 
#endif  // SERVER_CONFIG_HPP_