daemon_load_config.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "parser_json.h"
#include "parser_toml.h"
#include "parser_yml.h"
#include "daemon_load_config.h"
#include "daemon_config_exception.h"
#include <sstream>


void daemon_load_config(PLog & log, ConfigNode & dico, const PString & inputConfig, ConfigFormat::ConfigFormat format){
        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");
        }
}


void daemon_load_config(PLog & log, ConfigNode & dico, const PPath & configFile){
        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+"'");
        }
}


PString daemon_loadString(const ConfigNode & dico, const PString & attributeName){
        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 ");
}
 

void set_daemon_config_from_node(DaemonConfig & config, PLog & log, MapTimeout & mapTimeout, const ConfigNode & nodeDict, bool throwOnError)
{
        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;
                }
        }
}
 


void daemon_read_configNode(DaemonConfig & daemonConfig, MapDaemonConfig & mapDaemon,
                PLog & log, MapTimeout & mapTimeout, const ConfigNode *& extraConfigParam, const ConfigNode & dico, const PString & daemonName)
{
        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;
                }
        }
}