ConfAgent.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef ADF_ConfAgent
#include "ConfAgent.h"
#endif
#ifndef ADF_ConfigurationFrame
#include "ConfigurationFrame.h"
#endif
#ifndef ADF_RunAgent
#include "RunAgent.h"
#endif 
#ifndef ADF_DFAgent
#include "DFAgent.h"
#endif

#include <stdlib.h>

ADF::ConfAgent *ADF::ConfAgent::gTheGlobalAgent = 0x0;

using namespace ADF;
using namespace std;

namespace { UInt_t gAllocated = 0u; }

ConfAgent::ConfAgent() : DotConf("ADF::ConfAgent")
{ 
        gAllocated++;
        SetWithRecord(true);
} 

ConfAgent::~ConfAgent() 
{
        gAllocated--;
        
        if ( gAllocated == 1 ) {
#ifdef DEBUGSTATIC                      
                std::clog << "[[static]] ConfAgent::~ConfAgent() ]\n[...\n" ;
#endif
                KilltheGlobalAgent();
#ifdef DEBUGSTATIC                      
                std::clog << " done\n...]\n";   
#endif
        }
}

ConfAgent::EModel ConfAgent::GetModel(std::string model)
{
        ConfAgent::EModel m = ConfAgent::kSafe; 
        
        if ( model == "kStrict" )
                m = ConfAgent::kStrict;
        else if ( model == "kGrowing" )
                m = ConfAgent::kGrowing;
        
        return m;
}

const Char_t *ConfAgent::GetStringModel(ConfAgent::EModel m)
{
        const char *model = 0x0;
        switch (m) {
                case kStrict:
                        model = "kStrict";
                        break;  
                case kSafe:
                        model = "kSafe";                        
                        break;  
                case kGrowing:
                        model = "kGrowing";
                        break;
        }
        return model; 
}

void ConfAgent::KilltheGlobalAgent()
{
        if ( gTheGlobalAgent && gAllocated == 1 ) {
#ifdef DEBUGSTATIC                                      
                std::clog << "[[static]] KilltheGlobalAgent() ]\n[...\n" ;
                std::clog << " Destroying the global agent ... " << std::endl;
#endif          
                delete gTheGlobalAgent;
#ifdef DEBUGSTATIC                      
                std::clog << " done\n...]\n";   
#endif          
                gTheGlobalAgent = 0x0;  
        }
}


namespace ADF {
        

        class AgataConfAgent : public ConfAgent
        {       
        private:
                static AgataConfAgent *gTheGlobalAgent;
                
        private:
                DFAgent *fDFAgent;      
                RunAgent *fRunAgent;
                
        public:
                AgataConfAgent(); 
                AgataConfAgent(const char *);
                virtual ~AgataConfAgent(); 
                
                virtual DFAgent *GetDFAgent()
                { return fDFAgent ;}
                virtual RunAgent *GetRunAgent()
                { return fRunAgent ;}
                virtual const DFAgent *GetConstDFAgent() const
                { return const_cast<const DFAgent *> (fDFAgent) ;}
                virtual const RunAgent *GetConstRunAgent() const
                { return const_cast<const RunAgent *> (fRunAgent) ;}
                
                ConfAgent *Clone(const char *comment = "Clone of the global ConfAgent");
                
                // to get the global AGATA agent
                static AgataConfAgent *theGlobalAgent(); 
                
                virtual Bool_t Configure(const Char_t *name,  const char *option = "in", Bool_t allow_init = true)
                { return DotConf::Configure(name,option,allow_init); }
                virtual Bool_t Configure(ConfigurationFrame *,  const char *option = "in", Bool_t allow_init = false);
        };      
} // namespace

ADF::AgataConfAgent *ADF::AgataConfAgent::gTheGlobalAgent = 0x0;

AgataConfAgent::AgataConfAgent() : 
ConfAgent(), 
fDFAgent(new DFAgent("ADF::ConfAgent","Agata",true,true)), 
fRunAgent(new RunAgent("ADF::ConfAgent","Run"))
{       
        fLog.GetProcessName() = "ADF::AgataConfAgent"; 
        SetLastModif(); 
        
        if ( fDFAgent )
                AddConf(fDFAgent);
        if ( fRunAgent )
                AddConf(fRunAgent);     
        
        // configuration from the input file of the distribution
        // then the one pointed by ADF_CONF_PATH. if none of these two are found, try the current directory
        // if not found in the install path (make install not done properly)
        // try in the current directory
        std::string tmp; 
        
        // first the one in the distribution
        
        tmp = GetPathToConfFile();
        if ( tmp.size() > 0 && !(tmp.at(tmp.size()-1) == '/') ) 
                tmp += '/';
        tmp += "ADF.conf";
        
        if ( Configure(tmp.data(),"in") ) 
                fLog << info << "Init Global Conf Agent from distribution " << tmp << nline;
        else
                fLog << error << "Failed to init Global Conf Agent from distribution " << tmp << nline;
        
        // send snapshot of the agent in the log system
        if ( fLog.IsDebug(2) ) {
                fLog.SetLevel(LogMessage::kInfo,1);
                DoConfigure( fLog() );
                fLog.SetLevel(LogMessage::kInfo,0);
        }
        // second the one in the ADF_CONF_PATH path     or if not defined in the current directory
        if ( ::getenv("ADF_CONF_PATH") ) {
                
                tmp = ::getenv("ADF_CONF_PATH");
                
                if ( tmp.size() > 0 && !(tmp.at(tmp.size()-1) == '/') ) 
                        tmp += '/';
                tmp += "ADF.conf";
                if ( Configure(tmp.data(),"in") ) 
                        fLog << info << "Init Global Conf Agent from ADF_CONF_PATH " << tmp << nline;
                else 
                        fLog << warning << "Failed to init Global Conf Agent from ADF_CONF_PATH " << tmp << nline;
        }       
        else {
                fLog << warning << "ADF_CONF_PATH NOT DEFINED !, try init Global Conf Agent from current dir ..." << nline;
                if ( Configure("./ADF.conf","in") ) 
                        fLog << warning << "... DONE" << nline;
                else 
                        fLog << warning << "... FAILED" << nline;
        }
        
        // send snapshot of the agent in the log system
        if ( fLog.IsDebug(2) ) {
                fLog.SetLevel(LogMessage::kInfo,1);
                DoConfigure( fLog() );
                fLog.SetLevel(LogMessage::kInfo,0);
        }
        fLog << dolog;
} 

AgataConfAgent::AgataConfAgent(const char *comment) : 
ConfAgent(), 
fDFAgent(new DFAgent("ADF::ConfAgent","Agata",true,false)), 
fRunAgent(new RunAgent("ADF::ConfAgent","Run"))
{       
        fLog.GetProcessName() = "ADF::AgataConfAgent"; 
        SetComment(comment);
        
        if ( fDFAgent )
                AddConf(fDFAgent);
        if ( fRunAgent )
                AddConf(fRunAgent);     
} 

AgataConfAgent::~AgataConfAgent() 
{
        if ( fDFAgent ) {
                delete fDFAgent; fDFAgent = 0x0;
        }
        if ( fRunAgent ) {
                delete fRunAgent; fRunAgent = 0x0;
        }       
}

AgataConfAgent *AgataConfAgent::theGlobalAgent()
{
        if ( gTheGlobalAgent == 0x0 ) {
#ifdef DEBUGSTATIC                      
                std::clog << "[[static]]  Creating the global ConfAgent ]\n[...\n";
#endif
                // be sure factories global main factories are there  
                // the two main factories are added to the main factory in case it has not yet been done
                // key factory  
                if ( !MainKeyFactory::theMainFactory().IsKnown("Agata") )
                        MainKeyFactory::theMainFactory().Register("Agata");     
                // Frame factory
                if ( !MainFrameFactory::theMainFactory().IsKnown("Agata") )     
                        MainFrameFactory::theMainFactory().Register("Agata"); 
                
                gTheGlobalAgent = new AgataConfAgent(); 
                
#ifdef DEBUGSTATIC                      
                if ( gTheGlobalAgent ) 
                        std::clog << " done\n...]\n";
                else 
                { std::clog << " *** ERROR *** \n"; std::clog << "...]\n"; }
#endif          
        }
        return gTheGlobalAgent; 
        
}

ConfAgent *AgataConfAgent::Clone(const char *comment)
{       
        // check the global agent exists
        AgataConfAgent::theGlobalAgent();
        
        // first creats a new agent
        AgataConfAgent *aconf = new AgataConfAgent(comment);
        if ( aconf == 0x0 )
                return 0x0;
        
        // now copy the content of the global agent to it using Configure
        std::ostringstream o;  
        AgataConfAgent::theGlobalAgent()->DoConfigure(o);
        std::string tmp;
        tmp = o.str();
        std::istringstream i(tmp);
        aconf->DoConfigure(i,true); // the new agent is cloned, so reset it first ... even if aconf has just been created ... needed ?
        
        return aconf;
}

Bool_t AgataConfAgent::Configure(ConfigurationFrame *frame,  const char *option, Bool_t allow_init)
{
        // set reference to this method for log system
        fLog.SetProcessMethod("Configure(ConfigurationFrame *name)");
        
        Bool_t ok; std::string opt = option;
        
        if ( opt == "in" ) {
                // load the content of the frame in the string
                frame->Read();
                // use stream facility 
                std::istringstream in;
                in.clear();
                in.str((frame->String()));
                ok = DoConfigure(in, allow_init);
        }
        else {
                // use stream facility 
                std::ostringstream out;
                
                // the global conf frame starts an adf file. if the global conf file is not set properly (too high !)
                // the reading of the conf frame is cut and this could cause a wrong initialisation of the Agent.
                // to be safe, add some blank space 
                out << ends <<  ends << ends << ends << ends << ends << ends << ends << ends << ends << ends << ends;
                out << ends <<  ends << ends << ends << ends << ends << ends << ends << "\n";   
                ok = DoConfigure(out);
                frame->String() = out.str();
                frame->Write();
        }
        fLog << dolog;
        
        return ok;
}       

ConfAgent *ConfAgent::theGlobalAgent(std::string which_agent)
{ 
        if ( gTheGlobalAgent == 0x0 ) {
#ifdef DEBUGSTATIC                      
                std::clog << "[[static]]  Creating the global ConfAgent ]\n[...\n";
#endif
                if ( which_agent == "Agata" ) {
                        gTheGlobalAgent = AgataConfAgent::theGlobalAgent();
                }
#ifdef DEBUGSTATIC                      
                if ( gTheGlobalAgent ) 
                        std::clog << " done\n...]\n";
                else 
                { std::clog << " *** ERROR *** \n"; std::clog << "...]\n"; }
#endif          
        }
        return gTheGlobalAgent; 
}