BaseDaemon.h

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#ifndef __BASE_DAEMON_H__
#define __BASE_DAEMON_H__
 
#include <functional>
 
#include "OptionParser.h"
#include "parser_toml.h"
#include "PSocketFlag.h"
#include "PUncastableBool.h"
 
#include "daemon_config_exception.h"
#include "daemon_load_config.h"
#include "representation_def.h"
#include "FunctionCall.h"
#include "DataFunctionCall.h"
#include "DataFunctionClassCall.h"


#define SWARM_MAKE_SLOT(C,X,D) static PUncastableBool slot_##X(C & self, const D & _data){\
        return self.X(_data);\
}


#define SWARM_SLOT(X) slot_##X
 
typedef std::map<PString, std::map<PString, StatAccumulator> > MapDaemonStatAccumulator;
typedef std::map<PString, StatAccumulator> MapStatAccumulator;

struct DaemonMainConfig{
        int recvTimeoutMs{-1};
        int sendTimeoutMs{-1};
        PRecvFlag::PRecvFlag recvFlag{PRecvFlag::NON_BLOCK};
        PSendFlag::PSendFlag sendFlag{PSendFlag::NON_BLOCK};
};

class BaseDaemon{
        public:
                BaseDaemon();
                virtual ~BaseDaemon();
                
                bool parseArgument(int argc, char** argv);
                void loadConfigFromNode(const ConfigNode & dico, const PString & daemonName);
                bool load(const PString & configFileContent, const PString & daemonName, ConfigFormat::ConfigFormat format);
                bool load(const PPath & fileName, const PString & daemonName);
                
                virtual bool extraLoad(const ConfigNode * config);
                virtual void addCallMethod();
                

                template<typename _Callable>
                bool addCallableMethod(_Callable && function, const PString & name){
                        std::map<PString, AbstractFunction*>::iterator it(p_mapCallableMethod.find(name));
                        if(it != p_mapCallableMethod.end()){
                                getLog().getLogError() << "BaseDaemon::addCallableMethod : function '"<<name<<"' already added" << std::endl;
                                return false;
                        }
                        p_mapCallableMethod[name] = new FunctionCall(function, name);
                        return true;
                }
                
                bool callMethod(Data & result, const PString & name, const Data & parameter);
                void clearCallableMethod();
                
                void stop();
                OptionParser & getOptionParser();
                PLog & getLog();
                bool isDaemonExist(const PString & name) const;
                
                void addMessageToConfirm(const Message & message);
                bool getMessageToConfirm(Message & message, size_t id) const;
                void processConfirmedMessage(size_t id, time_t currentTime);
                void checkMessageTimeout(time_t currentTime);
                size_t getMessageId();
                

                template<typename _Data>
                bool addDataCallableMethod(PUncastableBool(&function)(const _Data &), size_t nbBin, float histLowerBound, float histUpperBound){
                        PString prototype(phoenix_getTypeToStr<_Data>());
                        std::cout << "BaseDaemon::addDataCallableMethod : prototype = " << prototype << std::endl;
                        std::map<PString, AbstractDataFunction*>::iterator it(p_mapDataFunction.find(prototype));
                        if(it != p_mapDataFunction.end()){
                                getLog().getLogError() << "BaseDaemon::addDataCallableMethod : function to process data '"<<prototype<<"' already added" << std::endl;
                                return false;
                        }
                        getLog().getLogDebug() << "BaseDaemon::addDataCallableMethod : add method to process data '"<<prototype<<"'" << std::endl;
                        p_mapDataFunction[prototype] = new DataFunctionCall(function, prototype);
                        p_config.getDaemonStatAccumulator().getMapStatComputing()[prototype] = createNewStat(nbBin, histLowerBound, histUpperBound);
                        return true;
                }


                template<typename _Class, typename _Data>
                bool addDataCallableMethod(PUncastableBool(&function)(_Class &, const _Data &), _Class & persistentData, size_t nbBin, float histLowerBound, float histUpperBound){
                        PString prototype(phoenix_getTypeToStr<_Data>());
                        std::cout << "BaseDaemon::addDataCallableMethod : prototype = " << prototype << std::endl;
                        std::map<PString, AbstractDataFunction*>::iterator it(p_mapDataFunction.find(prototype));
                        if(it != p_mapDataFunction.end()){
                                getLog().getLogError() << "BaseDaemon::addDataCallableMethod : function to process data '"<<prototype<<"' already added" << std::endl;
                                return false;
                        }
                        getLog().getLogDebug() << "BaseDaemon::addDataCallableMethod : add method to process data '"<<prototype<<"'" << std::endl;
                        p_mapDataFunction[prototype] = new DataFunctionClassCall(function, persistentData, prototype);
                        p_config.getDaemonStatAccumulator().getMapStatComputing()[prototype] = createNewStat(nbBin, histLowerBound, histUpperBound);
                        return true;
                }
 
                AbstractDataFunction* getDataFunction(const Data & data);
                bool processData(const Data & data);
 
                void updateStatAccumulator(StatAccumulator & stat, float value);
                StatAccumulator createNewStat(size_t nbBin, float histLowerBound, float histUpperBound);
                const std::map<size_t, Message> & getMapMessageToBeConfirmed() const;
                void clearStat();
 
                DaemonConfig & getConfig();
                MapDaemonConfig & getMapDaemonConfig();
                DaemonMainConfig & getMainConfig();
                PLog & getLogger();
 
        protected:
                VecStat fillVecStat(const StatAccumulator & accumulator, time_t startTimestamp, time_t endTimestamp);
                void fillDaemonStat(DaemonStat & stat, time_t startTimestamp, time_t endTimestamp);
                
                DaemonMainConfig p_mainConfig;
                DaemonConfig p_config;
                MapDaemonConfig p_mapDaemon;
                PLog p_log;
                bool p_isRun;
                bool p_isFullMock;
                bool p_isFullMockRecord;
                
        private:
                void initialisationBaseDaemon();
                std::map<PString, StatAccumulator> createNewCommunicationStatMap(const PString & dataType, size_t nbBin, float histLowerBound, float histUpperBound);
                void getCommunicationStat(const PString & destName, const PString & dataType, float latency, size_t nbBin, float histLowerBound, float histUpperBound);

                OptionParser p_optionParser;
                std::map<PString, AbstractFunction*> p_mapCallableMethod;
                std::map<size_t, Message> p_mapMessageToBeConfirmed;
                size_t p_messageId;
                
                std::map<PString, AbstractDataFunction*> p_mapDataFunction;
};
 
#endif