---

LcgInfoInterface.cpp

                              /* LcgInfoInterface.cpp */

/*
 *  Implementation of LcgInfoInterface.h
 */
#include <iostream>
#include "PSEUDO_SQLtoLDAPQuerier.h"
#include "LibFactory.h"
#include "ConfigBuffer.h"
#include "QueryTranslationException.h"
#include "TranslatorsUtils.h"
#include "LcgInfoInterface.h"

using namespace std;
using namespace LcgInfo;

LcgInfoInterface::LcgInfoInterface(){
}

LcgInfoInterface::~LcgInfoInterface(){
}


void LcgInfoInterface::initialize(LcgConfigBuffer::ConfigBuffer & pConf){
   mConf=&pConf;   
   prepareAll();
}

void LcgInfoInterface::initialize(string const & pConfFile){
   //First, get the mConfiguration data from the file
   mConf = new LcgConfigBuffer::ConfigBuffer();
   try{
      mConf->populate_from_config(pConfFile);
   }catch (LcgConfigBuffer::CBException& e){
       cerr << "initialize: Problems reading the main configuration file." << endl;
       cerr << e.what() << " +line: " << e.get_line() << " +file: " << e.get_file() << endl;
       exit (-1);
   }

   prepareAll();
}//end of initialize

void LcgInfoInterface::prepareAll(){   
   string library;
   string constructor_method;
   string destructor_method;
   vector<string> ifacesList;

   //Get the list of interfaces
   try{
      string ifaceAttr=mConf->get_attribute_value("INTERFACE_LIST");
      tokenizeStr(ifaceAttr,ifacesList);
   }catch (LcgConfigBuffer::CBException& e){
       cerr << "initialize: Problems loading the list of interfaces to be loaded." << endl;
       cout << e.what() << " +line: " << e.get_line() << " +file: " << e.get_file() << endl;
       exit (-1);
   }

   //Now, register all the specified libraries
   bool registered=false;
   for(vector<string>::iterator iface=ifacesList.begin(); iface!=ifacesList.end(); iface++){
      try{
         library=mConf->get_attribute_value(*iface+"_LIBRARY");
         constructor_method=mConf->get_attribute_value(*iface+"_LIBRARY_CONSTRUCTOR_METHOD");
         destructor_method=mConf->get_attribute_value(*iface+"_LIBRARY_DESTRUCTOR_METHOD");
         mFactory.Register(*iface, library, constructor_method, destructor_method);
         pair<string, destroy_Querier*> thePair(*iface, 0);
         mIfaces.insert(thePair);
         registered=true;
      }catch (LcgConfigBuffer::CBException& e){
          cerr << "initialize: Problems retrieving the library name for the interface \"";
          cerr << *iface << "\".\n";
          cerr << e.what() << " +line: " << e.get_line() << " +file: " << e.get_file() << endl;
      }
   }
   if(!registered){
      string msg="initialize: No library interface could be loaded. Aborting.";
      throw LcgInfoException(msg,__FILE__,__LINE__);
   }
}//end of prepareAll()


Querier * LcgInfoInterface::connect(){
   return connect((*(mIfaces.begin())).first);
}


Querier * LcgInfoInterface::connect(string const & pIface){
   Querier * querier=0;
   create_Querier* querierCreator=0;
   destroy_Querier* querierDestructor=0;
   
   map<string, destroy_Querier*>::iterator ifacePointer;
   if((ifacePointer=mIfaces.find(pIface))==mIfaces.end()){
      string msg="connect: The specified interface ("+pIface+") was not registered. Aborting.";
      throw LcgInfoException(msg,__FILE__,__LINE__);
   }
   if((*ifacePointer).second!=0){
      string msg="connect: A connection to the specified interface ("+pIface;
      msg += ") exist already. Aborting.";
      throw LcgInfoException(msg,__FILE__,__LINE__);            
   }

   try{
      // Load the appropriate library (appropriate interface) for the desired query
      
      if(mFactory.LibCreate(pIface, &querierCreator, &querierDestructor)==0){
         string msg="connect: The libraries for the specified interface ("+pIface;
         msg+= ") could not be loaded. Aborting.";
         throw LcgInfoException(msg,__FILE__,__LINE__);
      };   

      querier = querierCreator();
      mIfaces.erase(pIface);
      pair<string, destroy_Querier*> thePair(pIface, querierDestructor);
      mIfaces.insert(thePair);
   
      // Extract the interface specific mConfiguration information, and pass it to the Querier
      LcgConfigBuffer::ConfigBuffer * ifaceConf = new LcgConfigBuffer::ConfigBuffer();
      vector<string> attrList;
      attrList = mConf->list_attributes();

//debug
//for(int i=0; i<attrList.size(); i++){
//   cout << attrList.at(i) << endl;
//}
//end of debug

      for(vector<string>::iterator attr=attrList.begin(); attr!=attrList.end(); attr++){
         if(attr->find(pIface)==0){  //starts with correct prefix ==> relevant attr
            string newAttr=attr->substr(pIface.size()+1);
            ifaceConf->create_new_attribute(newAttr);  //store it without the prefix
            ifaceConf->set_attribute_value(newAttr, mConf->get_attribute_value(*attr));
         }
      }
      querier->setConfig(*ifaceConf);
      
   }catch(LcgConfigBuffer::CBException& e){
       string msg="connect: Problems when creating the connection (interface: " + pIface+ ").";
       msg += "\nUnderlying catched CBException message: " + e.what() + " +line: ";
       msg += int2str(e.get_line()) + " +file: " + e.get_file();
       throw LcgInfoException(msg,__FILE__,__LINE__);
    }
    catch(LcgInfo::QueryTranslationException & f){
       string msg="connect: Problems when creating the connection (interface: " + pIface+ "). ";
       msg += "\nUnderlying catched QueryTranslationException message: " + f.what() + " +line: ";
       msg += int2str(f.get_line()) + " +file: " + f.get_file();
       throw LcgInfoException(msg,__FILE__,__LINE__);
    }

    return querier;
}


void LcgInfoInterface::disconnect(string const & pIface, Querier * pIfaceHandler){
   
   map<string, destroy_Querier*>::iterator ifacePointer;
   if((ifacePointer=mIfaces.find(pIface))==mIfaces.end()){
      string msg="disconnect: The specified interface ("+pIface+") was not registered. Aborting.";
      throw LcgInfoException(msg,__FILE__,__LINE__);
   }
   if((*ifacePointer).second==0){
      string msg="disconnect: Trying to disconnect from a connection that did not exist";
      msg+= "(interface: " + pIface+ "). Aborting.";
      throw LcgInfoException(msg,__FILE__,__LINE__);            
   }
  
   //Destroy the Querier *
   (*ifacePointer).second(pIfaceHandler);
   //Deregister the interface
   (*ifacePointer).second=0;
}

---