daemon_load_config.cpp File Reference

#include "parser_json.h"
#include "parser_toml.h"
#include "parser_yml.h"
#include "daemon_load_config.h"
#include "daemon_config_exception.h"
#include <sstream>

Include dependency graph for daemon_load_config.cpp:

Go to the source code of this file.

Functions
void	daemon_load_config (PLog &log, ConfigNode &dico, const PPath &configFile)
	Load the daemon config into a ConfigNode.
void	daemon_load_config (PLog &log, ConfigNode &dico, const PString &inputConfig, ConfigFormat::ConfigFormat format)
	Load the daemon config into a ConfigNode from a json string.
PString	daemon_loadString (const ConfigNode &dico, const PString &attributeName)
	Load a string value.
void	daemon_read_configNode (DaemonConfig &daemonConfig, MapDaemonConfig &mapDaemon, PLog &log, MapTimeout &mapTimeout, const ConfigNode *&extraConfigParam, const ConfigNode &dico, const PString &daemonName)
	Read the ConfigNode to initialise current Daemon.
void	set_daemon_config_from_node (DaemonConfig &config, PLog &log, MapTimeout &mapTimeout, const ConfigNode &nodeDict, bool throwOnError)

Function Documentation

daemon_load_config() [1/2]

void daemon_load_config	(	PLog &	log,
		ConfigNode &	dico,
		const PPath &	configFile )

Load the daemon config into a ConfigNode.

Parameters

[out]	log	: log of the Daemon
[out]	dico	: ConfigNode with all the configuration
	configFile	: file name of the configuration

Returns

true on success, false otherwise

Definition at line 45 of file daemon_load_config.cpp.

                                                                                {
        PString extension = configFile.getExtension();
        if(extension == "toml"){
                if(!parser_toml(dico, configFile)){
                        log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "cannot load toml file '"+configFile+"'");
                }
        }else if(extension == "yml"){
                if(!parser_yml(dico, configFile)){
                        log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "cannot load yml file '"+configFile+"'");
                }
        }else if(extension == "json"){
                if(!parser_json(dico, configFile)){
                        log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "cannot load json file '"+configFile+"'");
                }
        }else{
                log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "unknown extension '"+extension+"' of config file '"+configFile+"'");
        }
}

daemon_load_config() [2/2]

void daemon_load_config	(	PLog &	log,
		ConfigNode &	dico,
		const PString &	inputConfig,
		ConfigFormat::ConfigFormat	format )

Load the daemon config into a ConfigNode from a json string.

Parameters

[out]	log	: log of the Daemon
[out]	dico	: ConfigNode with all the configuration
	inputConfig	: input string of the configuration
	format	: format of the configuration

Returns

true on success, false otherwise

Definition at line 21 of file daemon_load_config.cpp.

                                                                                                                    {
        if(format == ConfigFormat::JSON){
                if(!parser_jsonString(dico, inputConfig)){
                        log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "cannot load config from input string");
                }
        }else if(format == ConfigFormat::TOML){
                if(!parser_tomlString(dico, inputConfig)){
                        log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "cannot load config from input string");
                }
        }else if(format == ConfigFormat::YAML){
                if(!parser_ymlString(dico, inputConfig)){
                        log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "cannot load config from input string");
                }
        }else{
                log.criticalAndThrow<Phoenix::ParserException>("daemon_load_config", "unknown format '"+std::to_string(static_cast<int>(format))+"' of config");
        }
}

References ConfigFormat::JSON, ConfigFormat::TOML, and ConfigFormat::YAML.

Referenced by BaseDaemon::load(), and BaseDaemon::load().

Here is the caller graph for this function:

daemon_loadString()

PString daemon_loadString	(	const ConfigNode &	dico,
		const PString &	attributeName )

Load a string value.

Parameters

dico	: DicoValue to be used
attributeName	: name of the attribute to read

Returns

corresponding string

Definition at line 69 of file daemon_load_config.cpp.

                                                                                 {
        return phoenix_get_string(dico, attributeName, "unnamed_daemon").eraseFirstLastChar("\"'\t\n ");
//      return phoenix_load_value_from_config<PString>(dico, attributeName, "unnamed_daemon").eraseFirstLastChar("\"'\t\n ");
}

Referenced by daemon_read_configNode(), BaseDaemon::loadConfigFromNode(), and set_daemon_config_from_node().

Here is the caller graph for this function:

daemon_read_configNode()

void daemon_read_configNode	(	DaemonConfig &	daemonConfig,
		MapDaemonConfig &	mapDaemon,
		PLog &	log,
		MapTimeout &	mapTimeout,
		const ConfigNode *&	extraConfigParam,
		const ConfigNode &	dico,
		const PString &	daemonName )

Read the ConfigNode to initialise current Daemon.

Parameters

[out]	daemonConfig	: current Daemon configuration
[out]	mapDaemon	: map of all Daemon configuration
[out]	log	: log of the Daemon
[out]	mapTimeout	: map of all Daemon timeout
[out]	extraConfigParam	: pointer to extra configuration parameters of the Daemon (extra_parameter)
	dico	: ConfigNode to be used
	daemonName	: name of the current Daemon to load

Returns

true on success, false otherwise

Definition at line 114 of file daemon_load_config.cpp.

{
        const ConfigNode * mapBaseDaemon = dico.getChild("daemon");
        if(mapBaseDaemon == nullptr){
                log.criticalAndThrow<Phoenix::ConfigException>("BaseDaemon::daemon_read_configNode" , "Config doesn't contain a 'daemon' section'");
        }
 
        bool foundDaemonName(false);
        const VecConfigNode & vecBaseDaemon = mapBaseDaemon->getVecChild();
        //Make a first pass to load the current daemon to set the logger as soon as possible
        for(VecConfigNode::const_iterator it(vecBaseDaemon.begin()); it != vecBaseDaemon.end() && !foundDaemonName; ++it){
                if(daemon_loadString(**it, "name") == daemonName){
                        log.getLogInfo() << "BaseDaemon::daemon_read_configNode : configuration of current Daemon '"<<daemonName<<"' found" << std::endl;
                        //Set logger
                        log.setFileName(daemon_loadString(**it, "log_file"));
                        log.setLogLevel(phoenix_strToLogLevel(phoenix_get_string(**it, "log_level", "WARNING").eraseFirstLastChar("\"'\t\n ")));
                        if(!log.open()){
                                if(log.getMode() == PLog::FILE_ONLY || log.getMode() == PLog::FILE_CAPTURE_STDOUT_STDERR){
                                        log.criticalAndThrow<Phoenix::ConfigException>("BaseDaemon::daemon_read_configNode", "cannot open log file'"+log.getFileName()+"' of current daemon '"+daemonName+"' but log mode requires it.");
                                }else{
                                        std::cerr << "BaseDaemon::daemon_read_configNode : cannot open log file '"<<log.getFileName()<<"' of current daemon '"<<daemonName<<"'"<<std::endl;
                                }
                        }
                        set_daemon_config_from_node(daemonConfig, log, mapTimeout, **it, true);
                        //Extra-parameters of current daemon
                        extraConfigParam = (*it)->getChild("extra_parameter");
                        log.getLogInfo() << "BaseDaemon::daemon_read_configNode : Daemon '"<<daemonName<<"' on host '"<<daemonConfig.getHostName()<<"' and port "<<std::to_string(daemonConfig.getReceivingPort())<<" is configured !"<<std::endl;
                        foundDaemonName = true;
                }
        }
        if(!foundDaemonName){
                log.criticalAndThrow<Phoenix::ConfigException>("BaseDaemon::daemon_read_configNode", "current daemon '"+daemonName+"' not found!");
        }
        //Make second pass to load the other daemons, checking for duplicates definitions
        std::map<PString, PLocation> daemon_config_location;
        for(VecConfigNode::const_iterator it(vecBaseDaemon.begin()); it != vecBaseDaemon.end(); ++it){
                DaemonConfig config;
                config.setName(daemon_loadString(**it, "name"));
                //Check for duplicates
                std::map<PString, PLocation>::iterator daemon_config_location_iter = daemon_config_location.find(config.getName());
                if(daemon_config_location_iter != daemon_config_location.end()){
                        std::stringstream errorStringStream;
                        errorStringStream << "BaseDaemon::daemon_read_configNode : Current daemon '" << daemonName << "' defined twice,"
                                                          << " first at " << daemon_config_location_iter->second
                                                          << " then at " << (*it)->getLocation();
                        if(config.getName() == daemonName){
                                log.criticalAndThrow<Phoenix::ConfigException>("BaseDaemon::daemon_read_configNode", errorStringStream.str());
                        }else{
                                log.getLogWarning() << errorStringStream.str() << std::endl;
                        }
                }else{
                        daemon_config_location[config.getName()] = (*it)->getLocation();
                }
                if(config.getName() != daemonName){
                        set_daemon_config_from_node(config, log, mapTimeout, **it, false);
                        mapDaemon[config.getName()] = config;
                        log.getLogInfo() << "BaseDaemon::daemon_read_configNode : contact daemon '"<<config.getName()<<"' on host '"<<config.getHostName()<<"' and port "<<std::to_string(config.getReceivingPort())<<" loaded!"<<std::endl;
                }
        }
}

References daemon_loadString(), DaemonConfig::getHostName(), DaemonConfig::getName(), DaemonConfig::getReceivingPort(), set_daemon_config_from_node(), and DaemonConfig::setName().

Referenced by BaseDaemon::loadConfigFromNode().

Here is the call graph for this function:

Here is the caller graph for this function:

set_daemon_config_from_node()

void set_daemon_config_from_node	(	DaemonConfig &	config,
		PLog &	log,
		MapTimeout &	mapTimeout,
		const ConfigNode &	nodeDict,
		bool	throwOnError )

Set a daemon config from a configNode

Parameters

config	: configuration of the daemon
log	: log of the current daemon
mapTimeout	: map of all Daemon timeout
nodeDict	: ConfigNode with data to set the daemon config with.
throwOnError	if true: an error is thrown if setting the configuration fails. Otherwise an error is logged but execution continues.

Definition at line 81 of file daemon_load_config.cpp.

{
        config.setName(daemon_loadString(nodeDict, "name"));
        config.setDescription(daemon_loadString(nodeDict, "description"));
        config.setHostName(PString(phoenix_get_string(nodeDict, "hostname", "localhost")).eraseFirstLastChar("\"'\t\n "));
        config.setReceivingPort(phoenix_get_value<size_t>(nodeDict, "receiving_port", -1lu));
        config.setStatNbBin(phoenix_get_value<size_t>(nodeDict, "stat_nb_bin", 100lu));
        config.setStatHistLowerBound(phoenix_get_value<float>(nodeDict, "stat_hist_lower_bound", 0.f));
        config.setStatHistUpperBound(phoenix_get_value<float>(nodeDict, "stat_hist_upper_bound", 100.f));
        config.setStatTimerPeriodMs(phoenix_get_value<time_t>(nodeDict, "stat_timer_period", 1000lu));
        //Add the timeout of current config to global daemon config
        mapTimeout[config.getName()] = phoenix_get_value<size_t>(nodeDict, "daemon_required_response_timeout", 1000lu);
        if(config.getReceivingPort() >= 65536lu){
                std::string errorString("BaseDaemon::set_daemon_config_from_node : 'receiving_port' of Daemon '"+config.getName()+"' has invalid value '"+std::to_string(config.getReceivingPort())+"'");
                if(throwOnError){
                        log.criticalAndThrow<Phoenix::ConfigException>("BaseDaemon::set_daemon_config_from_node", errorString);
                }else{
                        log.getLogError() << errorString << std::endl;
                }
        }
}

References daemon_loadString(), DaemonConfig::getName(), DaemonConfig::getReceivingPort(), DaemonConfig::setDescription(), DaemonConfig::setHostName(), DaemonConfig::setName(), DaemonConfig::setReceivingPort(), DaemonConfig::setStatHistLowerBound(), DaemonConfig::setStatHistUpperBound(), DaemonConfig::setStatNbBin(), and DaemonConfig::setStatTimerPeriodMs().

Referenced by daemon_read_configNode().

Here is the call graph for this function:

Here is the caller graph for this function: