cdiCOOLDataHandle.cxx

//*************************************************************************************
//
//   cdiCOOLDataHandle.cxx
//   ----------
//   Implementation of the cdiCOOLDataHandle class.
//   
//   Nuno Barros    -  April 2005
//
//*************************************************************************************/


#include <sstream>
#include <algorithm>
#include <cstdlib>
#include <exception>


#include "cdi/cdiCOOLDataHandle.h"
#include "cdi/cdiAux.h"

#include <iostream>
#include <unistd.h>

// OnlineSW includes
#include <is/info.h>
#include <is/infoany.h>
#include <rc/Conditions.h>
#include <is/serveriterator.h>
#include <is/infoiterator.h>


// include of boos regex libraries
#include <boost/regex.hpp>



// Include files for COOL and it's dependencies
#include "AttributeList/AttributeList.h"
#include "CoolKernel/IDatabase.h"
#include "CoolKernel/IDatabaseSvc.h"
//#include "RelationalCool/timeToString.h"
#include "SealKernel/Exception.h"
#include "SealBase/TimeInfo.h"
#include "CoolKernel/ValidityKey.h"
#include "CoolApplication/DatabaseSvcFactory.h"

// Loading the POOLContext to preload the necessary modules
// avoiding the overhead during the run execution
#include "POOLCore/POOLContext.h"

//const std::string cdiCOOLDataHandle::configuration_name = "RunParams.Conditions";


// function to preload the necessary seal modules
void cdiCOOLDataHandle::loadSEALModules(){
  // pool::POOLContext::loadComponent( "POOL/Services/RelationalService" );
  pool::POOLContext::loadComponent( "POOL/Services/XMLAuthenticationService" );
  //  pool::POOLContext::loadComponent( "POOL/Services/EnvironmentAuthenticationService" );
  //  pool::POOLContext::loadComponent( "COOL/Services/DatabaseService" );
  // pool::POOLContext::loadComponent( "SEAL/Services/MessageService" );
  pool::POOLContext::loadComponent( "POOL/RelationalPlugins/oracle" );
  pool::POOLContext::loadComponent( "POOL/RelationalPlugins/sqlite" );
  pool::POOLContext::loadComponent( "POOL/RelationalPlugins/mysql/odbc" );

}



template <class T>
void cdiCOOLDataHandle::convert( ISInfoAny & isa, std::vector<std::string> & to )
{
  if ( isa.isAttributeArray() )
    {
      mout.warning("Trying to store an array...doing nothing...");
      
      std::vector<T> val;
      isa >> val;
      for ( size_t i = 0; i < val.size() ; i++ )
    {
      std::ostringstream out;
      out << val[i];
      to.push_back( out.str() );
    }
    }
  else
    {
      T val;
      isa >> val;
      std::ostringstream out;
      out << val;
      to.push_back( out.str() );
    }
}

// due to the refatoring of data types correspondance we will use the seal::IntBits<64>::ULeast

void cdiCOOLDataHandle::convertTime (ISInfoAny & isAny, seal::IntBits<64>::ULeast &time) { //unsigned long long &time) {
  OWLTime pTime;
  isAny >> pTime;
  std::string test;
  test = pTime.c_str();
  mout.verbose("The time given is " + test);

  // this will give the seconds from 1st january of 1970
  // we need to multiply by 10^9 to get the nanoseconds
  time = pTime.c_time();
  time *= 1000000000;
  std::ostringstream msg;
  msg << "cdiCOOLDataHandle::convertTime> Time resulted: [" << time << "]";
  mout.verbose(msg.str());
}


bool cdiCOOLDataHandle::existDB(std::string dbProfile) 
{
  try {
    cool::IDatabasePtr db = m_dbSvc->openDatabase(dbProfile);
    cool::IDatabasePtr dbNull;
    m_db = dbNull;
    
    return true;
  }
  catch(seal::Exception &e) {
    cool::IDatabasePtr dbNull;
    m_db = dbNull;
    
    return false;
  }
}

void cdiCOOLDataHandle::getConfig( std::vector<std::string> & names )
{
  // first let's get the dictionary for the partition
  // This will allow to retrieve any object that might be needed (RunParams.Conditions)
  ISInfoDictionary dictionary(partition);
  
  //let's retrieve the conditions object that contains the list of subscribed objects 
  
  Conditions conditions;
  ISInfo::Status status = dictionary.findValue( configuration_name.c_str(), conditions );
  
  mout.debug( std::string("cdiCOOLDataHandle::getConfig: Getting Informations to subscribe"));
  
  names.clear();
  
  if ( status == ISInfo::Success)
    names = conditions.isservers;
  
  // The RunParams.RunParams object is mandatory
  if ( std::find( names.begin(), names.end(), std::string( "RunParams.RunParams" )) == names.end() ) {
    mout.verbose( std::string("cdiDataHandle::getConfig> Adding [RunParams.RunParams] to names"));
    names.push_back( "RunParams.RunParams" );
  }
  
  //The conditions holder object shall also be stored to keep
  // track of the subscription commands issued by the users
  if ( std::find( names.begin(), names.end(), configuration_name ) == names.end() ) {
    mout.verbose( std::string("cdiDataHandle::getConfig> Adding [" + configuration_name+ "] to names"));
    names.push_back( configuration_name );
  }

  // Here we need to proceed to two different issues
  // We need to move the time consuming tasks to the initialisation (here)
  // Time consuming tasks: (folder verification and creation, attributelist generation)
  
  // we also need to store the values existing in the object at the moment of the
  // subscription and not only after the first update

  // we also need to be careful for the case that the object has already been stored...
  // COOL is very strick with overlaping IOVs
  
  std::vector<std::string>::const_iterator itEnd = names.end();

  
  //we shall use the m_objs vector 

  /***
   // a new container is needed to store the real names of the objects to be stored
   std::vector<std::string> pNames;
  ***/
  
  // The object of the name
  std::string objName;
  // To avoid the overloading of the IS I'm just going to cycle once through
  // The whole list of servers and objects
  
  ISServerIterator ISit(partition);
  while( ISit() ){
    objName = ISit.name();
    mout.verbose(std::string("Checking the server [" + objName + "]"));
    
    ISInfoIterator ii(partition,ISit.name());
    while( ii() ){
      // let's finally iterate under all the subscribed names from the user
      objName = ii.name();
      mout.verbose(std::string("getConfig -> Starting to check object [" + objName + "]"));
      
      for (  std::vector<std::string>::const_iterator it = names.begin(); it != itEnd; ++it){
    boost::regex expression((*it).c_str());
    boost::cmatch what;
    // using the boost regex library let's see if the current object matches any of the 
    // user defined elements in the names list
    if (boost::regex_match(objName.c_str(),expression)){
      mout.verbose(std::string("getConfig -> [" + objName + "] matches the expression [" + (*it) + "]"));
      //let's see if we have already stored this object
      if ( std::find( m_objs.begin(), m_objs.end(), objName ) == m_objs.end() ) {
        mout.verbose( std::string("cdiDataHandle::getConfig> Adding [" + objName + "] to list"));
        m_objs.push_back( objName );
        
        // let's proceed to storage of the object with its current contents
        ISInfoAny isa;
        ii.value(isa);
        storeObject(objName, isa);
      }
      else {
        mout.verbose( std::string("cdiDataHandle::getConfig> Object [" + objName + "] already added to the list"));
      }
    }
    else {
      mout.verbose(std::string("getConfig -> [" + objName + "] does not match the expression [" + (*it) + "]"));
    }
    
      }
    }
  }
  mout.debug( std::string("cdiDataHandle::getConfig> Returning without problems"));
}


/*
 void cdiCOOLDataHandle::getConfig( std::vector<std::string> & names )
 {
 ISInfoDictionary dictionary(partition);
 
 Conditions conditions;
 ISInfo::Status status = dictionary.findValue( configuration_name.c_str(), conditions );
 
 mout.debug( std::string("Getting Informations to subscribe"), 2);
 // let's reset the container to store a new set of ISServer's
 names.clear();
 
 // fill the vector with the ISServer's list
 if ( status == ISInfo::Success)
 names = conditions.isservers;
 
 // if the RunParams.RunParams is not in the list returned we'll subscribe it from our side
 if ( std::find( names.begin(), names.end(), std::string( "RunParams.RunParams" ) ) == names.end() )
 names.push_back( "RunParams.RunParams" );
 // RunParams.RunInfo is no longer used
 //    if ( std::find( names.begin(), names.end(), std::string( "RunParams.RunInfo" ) ) == names.end() )
 // names.push_back( "RunParams.RunInfo" );
 
 // let's subscribe RunParams.Conditions
 if ( std::find( names.begin(), names.end(), configuration_name ) == names.end() )
 names.push_back( configuration_name ); 
 }
*/

std::string cdiCOOLDataHandle::getProfile()
{

  std::string preffix = "Environment variable ";
  preffix += char(27);
  preffix += "[1m";
  std::string suffix = "";
  suffix += char(27);
  suffix += "[0m"; 
  

  // first let's check if the mandatorz env vars are defined
  char * tmp2 = getenv( "SEAL_PLUGINS" );
  
  if ( tmp2 == 0 )
    {
      mout.error(std::string(preffix + "\'SEAL_PLUGINS\'" + suffix + " must be defined to point to the plugins folders!"));
      mout.info( "CDI will exit now." );
      ISInfo::Status status = ISInfo::NotFound;
      std::string msg = cdiCOOLDataHandle::dumpFailure( status );
      mout.error(msg);
      exit(1);
    }
  
  tmp2 = getenv( "SEAL_KEEP_MODULES" );
  
  if ( tmp2 == 0 )
    {

      mout.error(std::string(preffix + "\'SEAL_KEEP_MODULES\'" + suffix + " must be defined to \"true\""));
      /*** Experiment to set the env var on my own
       mout.info( "CDI will exit now." );
       ISInfo::Status status = ISInfo::NotFound;
       //      exit(status);
       */
      if (setenv("SEAL_KEEP_MODULES","true",1) != 0){
    mout.error(std::string(preffix + "\'SEAL_KEEP_MODULES\'" + suffix + " was not possible to be set up automatically!"));
    /*
    mout.error(std::string("Unable to set up" 
                   + char(27)+ "[1m" + "\'SEAL_KEP_MODULES\'" + char(27)+ "[0m" 
                   + " to" + char(27)+ "[4m" + " \'true\'" + char(27)+ "[0m"));
    
      mout.error(std::string("Unable to set up" 
      + char(27)+ "[1m" + "\'SEAL_KEP_MODULES\'" + char(27)+ "[0m" 
      + " to" + char(27)+ "[4m" + " \'true\'" + char(27)+ "[0m"));
    */  
      }
      if (getenv( "SEAL_KEEP_MODULES" ) == 0){
    mout.error(std::string(preffix + "\'SEAL_KEEP_MODULES\'" + suffix + " is still not in the environment!"));
    
    exit(1);
      }
    }
  else {
    if (tmp2 != "true"){
      mout.verbose(std::string("SEAL_KEEP_MODULES="+ std::string(tmp2)));
    }
  }

  // to avoid messing up for now the environment variable will be different
  // Now we'll use COOL_DBID
  char *tmp = getenv( "TDAQ_COOL_PROFILE" );
  
  if ( tmp == 0 ) {
      mout.error(std::string(preffix + "\'TDAQ_COOL_PROFILE\'" + suffix + " is not defined with the DB connection string"));
      mout.info( "CDI will exit now." );
      exit(1);
  }
  
  return std::string(tmp);
}

void cdiCOOLDataHandle::get_folder_specs(std::string fname,pool::AttributeListSpecification &payloadSpec) {
  
  try
    {
      mout.debug(std::string("Getting specification for folder [" + fname + "]"),3);
      // first we check if the folder exist.
      if ( m_db->existsFolder( fname )) {
    
    //let's get the folder pointer
    m_fld = m_db->getFolder( fname );
    
    // next we get the schema of the objects in the folder
    payloadSpec = m_fld->payloadSpecification();
    
    // some aditional debug information that will *NEVER* be used 
#ifdef DEBUG
    std::ostringstream AttrSpec;
    payloadSpec.print(AttrSpec);
    mout.verbose(std::string("<cdiCOOLDataHandle::get_folder_specs> Describing AttributeList:" + AttrSpec.str()));
    AttrSpec.~ostringstream();
#endif
    
    mout.debug(std::string("<cdiCOOLDataHandle::get_folder_specs> Folder Attribute List Specification read from the database!"));
    return;
      }
      else {
    mout.error(std::string("<cdiCOOLDataHandle::get_folder_specs> Folder does not exist in the database... "));
    exit(1);
      }
    }
  catch (seal::Exception &e)
    {
      std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
      exit( 1 );
    }
}



void cdiCOOLDataHandle::fillTypes()
{
  
  // let's try with this data type mapping
  // Simple types
  m_dTypes.insert( std::make_pair( ISType::Boolean,"bool" ) );
  m_dTypes.insert( std::make_pair( ISType::S16, "short"  ) ); // 16 bits integer
  m_dTypes.insert( std::make_pair( ISType::U16, "unsigned short") );
  m_dTypes.insert( std::make_pair( ISType::S32, "long" ) );
  m_dTypes.insert( std::make_pair( ISType::U32, "unsigned long" ) );
  m_dTypes.insert( std::make_pair( ISType::Float, "float" ) );
  m_dTypes.insert( std::make_pair( ISType::Double,"double" ) );
  m_dTypes.insert( std::make_pair( ISType::S8,  "short" ) );
  m_dTypes.insert( std::make_pair( ISType::U8,  "unsigned short" ) );
  m_dTypes.insert( std::make_pair( ISType::String,  "string" ) );
  // time cannot be negative...we will use unsigned
  m_dTypes.insert( std::make_pair( ISType::Date, "unsigned long long" ) );
  m_dTypes.insert( std::make_pair( ISType::Time, "unsigned long long" ) );
  
}


/***
 cdiCOOLDataHandle::cdiCOOLDataHandle( int verbosity, const IPCPartition & p )
 : partition( p ),
 mout( verbosity ),
 configuration_name("RunParams.Conditions")
 {
 mout.info(std::string("Initializing CDI Data Handle.."), 3);
 
 cdiCOOLDataHandle::fillTypes();
 
 try {
 init( getProfile() );
 }
 catch (seal::Exception &e) {
 std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
 exit( 1 );
 }
 }
 
***/


cdiCOOLDataHandle::cdiCOOLDataHandle( int verbosity, const IPCPartition & p, const std::string confName)
  :     mout( verbosity ),
    partition( p ), 
    configuration_name(confName)
{
  mout.info(std::string("Initializing CDI Data Handle.."), 3);
  
  cdiCOOLDataHandle::fillTypes();
  cdiCOOLDataHandle::loadSEALModules();
  
  try {
    init( getProfile() );
  }
  catch (seal::Exception &e) {
    std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
    exit( 1 );
  }
}

void cdiCOOLDataHandle::init( const std::string & profile )
{
  try {
    mout.debug(std::string("Initializing COOL....."));  

    mout.verbose(std::string("COOL PROFILE ->[" + profile + "]"));

    m_dbSvc = &(cool::DatabaseSvcFactory::databaseService());
    
    // we should verify if the profile is valid
    // TODO: Verification if the profile is valid
    
    // define the database id
    // the dbIdStr must be in the form: <tech>://<server>;schema=<schema>;username=<user>;password=<pwd>;dbname=<db>
    m_dbId = profile;
    mout.verbose(std::string("Checking again in profile to verify if the database exists"));
    
    std::string out = "Checking if the COOL DB exists...";

    if (cdiCOOLDataHandle::existDB( m_dbId )) {
      out += "yes!";
      mout.verbose(out);
      mout.debug(std::string("Opening the COOL DB"));
      m_db = m_dbSvc->openDatabase( m_dbId );
    }
    else 
    {
      out += "no!";
      mout.verbose(out);
      mout.debug(std::string("Creating the COOL DB"));
      /*
    std::ostringstream bla;
    bla << "DBID=" << m_dbId << std::endl;
    mout.verbose(bla.str());
      */
      m_db = m_dbSvc->createDatabase( m_dbId );
    }
  }
  catch (seal::Exception &e)
    {
      std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
      exit( 1 );
    }
  catch (...) {
    std::cerr << "Funny exception caught...from where?" << std::endl;
    exit ( 1 );
  }
  
}

bool cdiCOOLDataHandle::is_table_exist ( const std::string & name )
{
  mout.info(std::string("Entering <cdiCOOLDataHandle::is_table_exist>"), 2);
  std::map <std::string, pool::AttributeListSpecification>::iterator it = m_Tables.begin();
  for( ; it != m_Tables.end(); ++it )
    {
      if ( it->first == name )
    return true;
    }
  return false;
}

void cdiCOOLDataHandle::add_table ( pool::AttributeListSpecification &attSpec, const std::string & name )
{
  mout.debug(std::string("Entering <cdiCOOLDataHandle::add_table>"));
  
#ifdef DEBUG
  std::ostringstream debug;
  //  debug << "<cdiCOOLDataHandle::add_table> Dumping AttrListSpec address: [" << &attSpec << "]";
  
  mout.verbose("Printing the AttributeListSpec to be added");
  attSpec.print(debug);
  mout.verbose(debug.str());
  debug.~ostringstream();
#endif

  m_Tables.insert( std::make_pair( name, attSpec ) );

}

std::string cdiCOOLDataHandle::dumpFailure(  ISInfo::Status status )
{
  std::string msg;
  switch (status) {
  case ISInfo::CommFailure:
    msg = "Comunication failure [ISInfo::CommFailure]"; break;
  case ISInfo::AlreadyExist:
    msg = "Information Already Exist [ISInfo::AlreadyExist]"; break;
  case ISInfo::NotFound:
    msg = "Information Not Found [ISInfo::NotFound]"; break;
  case ISInfo::InvalidInfo:
    msg = "Invalid Information [ISInfo::InvalidInfo]"; break;
  case ISInfo::IncompatibleType:
    msg = "Incompatible Information Type [ISInfo::IncompatibleType]"; break;
  case ISInfo::InvalidCriteria:
    msg = "Invalid Criteria [ISInfo::InvalidCriteria]"; break;
  case ISInfo::RepositoryNotFound:
    msg = "Information Repository not found [ISInfo::RepositoryNotFound]"; break;
  case ISInfo::ProviderNotFound:
    msg = "Information Provider not Found [ISInfo::ProviderNotFound]"; break;
  case ISInfo::InvalidName:
    msg = "Invalid Information Name [ISInfo::InvalidName]"; break;
  default:
    msg = "Unknown problem with Information"; break;
  }
  
  mout.error(msg);
  return msg;

}

void cdiCOOLDataHandle::create_folder ( const std::string & name, ISInfoAny & isa )
{  
  mout.info( std::string( "Entering <cdiCOOLDataHandle::create_folder> " + name ), 2 );
  
  // first check if the AttList already exists in the container
  // if it exists just gets out of method and continue execussion of the program
  if ( is_table_exist( name ) )
    {
      mout.debug("Entering <cdiCOOLDataHandle::create_folder> Folder already exist. Ignoring...");
      return;
    }
  
  mout.debug("Entering <cdiCOOLDataHandle::create_folder> Folder doesn't exist in map.Continuing...");
  
  //let's generate the folder name
  // it uses the partition name and the key name which is the release
  std::string fname = std::string("/TDAQ/" + partition.name() + "/" + name);
  
  //let's create the AttrList specification that will hold the schema
  pool::AttributeListSpecification payloadSpec;
  pool::AttributeList payload;
  
  // first let's check if the folder exists in the database
  mout.debug("<cdiCOOLDataHandle::create_folder> Trying to read Attribute List Specification from the database!");
  
  try
    {
      // first we check if the folder exist.
      if ( m_db->existsFolder( fname )) {
    
    //let's get the folder pointer
    m_fld = m_db->getFolder( fname );
    
    // next we get the schema of the objects in the folder
    //  payloadSpec = m_fld->getPayloadSpecification();
    payloadSpec = m_fld->payloadSpecification();

#ifdef DEBUG    
    std::ostringstream AttrSpec;
    payloadSpec.print(AttrSpec);
    mout.verbose(std::string("<cdiCOOLDataHandle::create_folder> Describing AttributeList:" + AttrSpec.str()));
    AttrSpec.~ostringstream();
#endif
    //  mout.info(std::string("Sleeping..."),1);
    //  seal::TimeInfo::sleep(1);
    
    // and finally add it to the container
    add_table( payloadSpec, name );
    mout.debug("<cdiCOOLDataHandle::create_folder> Folder Attribute List Specification read from the database!");
    return;
      }
      else {

    // The folder doesn't exist in the database
    mout.debug("<cdiCOOLDataHandle::create_folder> Folder does not exist in the database...continuing to create it!");
      }
    }
  catch (seal::Exception &e)
    {
      std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
      exit(1);
    }
  
  // If the execution comes until here, it means that the folder does not exist in the database
  // neither in the container
  // so we need to do everything since the beginning
  mout.debug("<cdiCOOLDataHandle::create_folder> Creating folder [" + fname + "]in the database!");
  
  // Loading the Document name and description to get the attributes
  mout.debug(std::string("<cdiCOOLDataHandle::create_folder> Getting the ISInfoDocument for partition [" + partition.name() + "] !"));
  ISInfoDocument isd( partition, isa );
  
  // Something is tricky here. If it fails to load the Document, it should not continue
  if ( isd.status() == ISInfo::Success )
    {
      mout.verbose(std::string("<cdiCOOLDataHandle::create_folder> isd.name: [" + isd.name() + "]"));
      mout.verbose(std::string("<cdiCOOLDataHandle::create_folder> isd.description: [" + isd.description() + "]"));
    }
  else
    {
      mout.verbose(std::string("<cdiCOOLDataHandle::create_folder> IS description for [" + isd.name() + "] is not available" ));
      mout.verbose(std::string("Risk of segfault caused by failure to load ISInfoDocument"));
      std::string msg = cdiCOOLDataHandle::dumpFailure(isd.status());
    }
  
  std::ostringstream msg;
  msg << "ISInfoDocument has [" << isa.countAttributes() << "] attributes which will be dumped...";
  mout.verbose(msg.str());
  msg.seekp(0);  
  
  // now we must be aware of the existence of the arrays
  // in this case a warning message will be isued and the column will be ignorated
  std::string warnMsg = "WARNING:Trying to store an object containing an array. Arrays are not suported. Ignoring column ";

  // let's cycle through the attributes
  for ( size_t i = 0; i < isa.countAttributes(); i++ )
    {
      const ISInfoDocument::Attribute * attr = 0;
      if ( isd.status() == ISInfo::Success) {
    attr = isd.attribute( i );
      }
      std::ostringstream colName, wMsg;
      
      colName << "column_" << i;
      if (isa.isAttributeArray()) {
    wMsg << warnMsg << i;
    mout.info(wMsg.str());
    
    // jump to the next attribute
    //break;
      }
      
      std::ostringstream msg, msg2;
      //let's put the data in the payloadSpec
      msg << "Attribute name: [" << attr->name() << "] Attribute type: [" 
          <<  m_dTypes[isa.getAttributeType()] << "] <-> [" << isa.getAttributeType()
          << "]"; 
      if (isa.isAttributeArray()){
    msg << " ARRAY=[YES]"; 
      }
      else {
    msg << " ARRAY=[NO]"; 
      }
      mout.verbose(msg.str());
      /*
    mout.verbose("USING the Document Attribute");
    msg2 << "Attribute name: [" << attr->name() << "] Attribute type: [" 
    <<  attr->typeName() << "] <-> [" << attr->typeCode() << "]"; 
    mout.verbose(msg.str());
      */
      if (isa.isAttributeArray()){
    std::string name;
    if (attr) {
      name =  attr->name() + "$ARRAY$" + m_dTypes[isa.getAttributeType()];
    }
    else {
      name = colName.str() + "$ARRAY$" + m_dTypes[isa.getAttributeType()];
    }
    
    payloadSpec.push_back(name,"string");
      } 
      else {
    payloadSpec.push_back(attr ? attr->name() : colName.str(),m_dTypes[isa.getAttributeType()]);
      }
      // Due to a COMPLETELY unknown reason we need to get the data from the ISInfoAny in order to go to the next 
      // element...I really wonder why...
      
      std::vector<std::string> cell;
      seal::IntBits<64>::ULeast cellT;

      switch ( isa.getAttributeType() ) 
    {
    case ISType::Boolean: { convert<bool>( isa, cell ); break; }
    case ISType::S16: { convert<short>( isa, cell ); break; }
    case ISType::U16: { convert<unsigned short>( isa, cell ); break; }
    case ISType::S32: { convert<long>( isa, cell ); break; }
    case ISType::U32: { convert<unsigned long>( isa, cell ); break; }
    case ISType::Float: { convert<float>( isa, cell ); break; }
    case ISType::Double: { convert<double>( isa, cell ); break; }
    case ISType::S8: { convert<char>( isa, cell ); break; }
    case ISType::U8: { convert<unsigned char>( isa, cell ); break; }
    case ISType::String: { convert<std::string>( isa, cell ); break; }
    case ISType::Date: { convertTime( isa, cellT ); break; }
    case ISType::Time: { convertTime( isa, cellT ); break; }
    case ISType::Error:
    default: { mout.error("IS Attribute Error "); break; }
    }
      // }
    }
  
  // let's reset the ISAttributeList
  isa.reset();
  
  // Let's create the folder in the database
  try
    {
      //Creating the folder in the database
      mout.debug(std::string("<cdiCOOLDataHandle::create_folder> Proceeding to folder " + name + " creation... "));
      // there is still need to define the folder description to read from Athena
      m_fld = m_db->createFolder( fname, 
                  payloadSpec, 
                  "", 
                   cool::FolderVersioning::MULTI_VERSION,
                  //                  cool::FolderVersioning::SINGLE_VERSION,
                  true );

      m_fName = fname;
      mout.verbose("<cdiCOOLDataHandle::create_folder> Folder created!");

      // finally let's add the AttListSpec to the map
      add_table( payloadSpec, name );

    }
  // if an exception is catched here we cannot continue
  catch (seal::Exception &e)
    {
      std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
      exit( 1 );
    }
}


void cdiCOOLDataHandle::process_data ( const std::string & name, ISCallbackInfo * isc )
{
  mout.debug("Entering <cdiCOOLDataHandle::process_data>");

  ISInfoAny isa;
  isc->value( isa );

  storeObject(name,isa);
  
}

  void cdiCOOLDataHandle::storeObject(const std::string & name, ISInfoAny &isa) {

  // taking care of the folder name
  std::string rVersion = RELEASE_NAME;
  std::string fSuffix;
  std::string::size_type beg = rVersion.find("-");
  
  if (beg != std::string::npos)
    fSuffix = rVersion.substr(beg);
  else 
    fSuffix = "-" + rVersion;
  
  std::string foldName = name + fSuffix; 
  
  // let's check if the folder exists already in some place and create it in case it doesn't
  cdiCOOLDataHandle::create_folder ( foldName, isa );
 
  // if it fails here, I cannot understand the problem
  mout.verbose(std::string("<cdiCOOLDataHandle::process_data> Folder [" + foldName + "] create and added to the map!" ));
  mout.verbose(std::string("<cdiCOOLDataHandle::process_data> Getting AttributeList corresponding to folder [" + foldName + "]" ));
  
  std::ostringstream debug;
  debug << "<cdiCOOLDataHandle::process_data> The map constains [" << m_Tables.size() << "] elements";
  mout.verbose(debug.str());
  debug.seekp(0);
  
   // let's get the AttrList Specification
  pool::AttributeListSpecification payloadSpec = m_Tables[foldName];
  
  try {
    
    mout.verbose(std::string("<cdiCOOLDataHandle::process_data> Describing the AttrList Specs"));
    

#ifdef DEBUG
    std::ostringstream AttrSpec;
    payloadSpec.print(AttrSpec);
    mout.verbose(std::string("<cdiCOOLDataHandle::writeData> Describing AttributeList:"));
    mout.verbose(AttrSpec.str());
    AttrSpec.seekp(0);
#endif

  }
  catch(seal::Exception &e){
    std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
    exit( 1 );
  }
  catch(...) {
    std::cerr << "Unknow exception caught describing the AttrLstSpec in map" << std::endl;
    exit( 1 );
  }
  
  mout.verbose("<cdiCOOLDataHandle::writeData> Filling AttrList");
  pool::AttributeList pList(payloadSpec);
  
  // let's get the data
  // now we can convert directly from the ISAttributeList to the Attribute
  for( size_t n = 0; n < isa.countAttributes(); n++ )
    {
      
      try{
    
    switch ( isa.getAttributeType() ){
    case ISType::Boolean: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<bool>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "bool" << "]" ;
      mout.verbose(msg.str());
      bool aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<bool>(aux);
      }
      break; 
    }
    case ISType::S16: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<int>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "int" << "]" ;
      mout.verbose(msg.str());

      short int aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<short>(aux);
      }
      break; 
    }
    case ISType::U16: {
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<unsigned int>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
        
        
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "unsigned int" << "]" ;
        mout.verbose(msg.str());
        unsigned short int aux;
        isa >> aux;
        pList[payloadSpec[n].name()].setValue<unsigned short>(aux);
      }   
      break; 
    }
    case ISType::S32: { 
          if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<long>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "long" << "]" ;
      mout.verbose(msg.str());

      long aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<long>(aux);
      }
      break; 
    }
    case ISType::U32: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<unsigned long>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "unsigned long" << "]--" ;
      mout.verbose(msg.str());

      unsigned long aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<unsigned long>(aux);
      }
      break; 
    }
    case ISType::Float: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<float>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "float" << "]" ;
      mout.verbose(msg.str());
      float aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<float>(aux);
      // convert<float>( isa, cell );
      }
      break;
    }
    case ISType::Double: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<double>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "double" << "]" ;
      mout.verbose(msg.str());
      double aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<double>(aux);
      }
      break; 
    }
    case ISType::S8: {
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<short>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "int" << "]" ;
      mout.verbose(msg.str());
 
      short int aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<short>(aux);
      }
      break; 
    }
    case ISType::U8: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<unsigned short>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "unsigned int" << "]" ;
      mout.verbose(msg.str());
      unsigned short int aux;
      isa >> aux;
      pList[payloadSpec[n].name()].setValue<unsigned short int>(aux);
      }
      break; 
    }
    case ISType::String: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());
        std::ostringstream aux;
        std::vector<std::string> vec;
        convert<std::string>(isa,vec);
        for (size_t pos = 0; pos < vec.size(); pos ++){
          aux << vec[pos];
          if (pos  != (vec.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "string" << "]" ;
        mout.verbose(msg.str());
        std::string aux;
        isa >> aux;
        pList[payloadSpec[n].name()].setValue<std::string>(aux);
      }
      break; 
    }
      // this might be tricky. What is the primitiver data tiem for date and time values?
    case ISType::Date: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());

        std::ostringstream aux;
        seal::IntBits<64>::ULeast time;



        std::vector<OWLTime> pTime;
        isa >> pTime;

        for (size_t p = 0; p < pTime.size(); p++){
          time = pTime[p].c_time();
          time *= 1000000000;
          aux << time;
          if (p != (pTime.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "Date" << "]" ;
      mout.verbose(msg.str());
      
      seal::IntBits<64>::ULeast aux;
      cdiCOOLDataHandle::convertTime( isa, aux ); 
      pList[payloadSpec[n].name()].setValue<seal::IntBits<64>::ULeast>(aux);
      }
      break; 
    }
    case ISType::Time: { 
      if (isa.isAttributeArray()) {
        mout.warning("The attribute is an array...still under testing");
        std::ostringstream msg;
        msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
        << "ARRAY[STRING]" << "]" ;
        mout.verbose(msg.str());

        std::ostringstream aux;
        seal::IntBits<64>::ULeast time;



        std::vector<OWLTime> pTime;
        isa >> pTime;

        for (size_t p = 0; p < pTime.size(); p++){
          time = pTime[p].c_time();
          time *= 1000000000;
          aux << time;
          if (p != (pTime.size()-1)){
        aux << ":";
          }
        }
        pList[payloadSpec[n].name()].setValue<std::string>(aux.str());
        
      }
      else {
 

      std::ostringstream msg;
      msg << "Parameter [" << n << "]: [" << payloadSpec[n].type_name() << "]<->["
          << "Time" << "]" ;
      mout.verbose(msg.str());
      
      seal::IntBits<64>::ULeast aux;
      cdiCOOLDataHandle::convertTime( isa, aux ); 
      pList[payloadSpec[n].name()].setValue<seal::IntBits<64>::ULeast>(aux);
      }
      break; 
    }
    case ISType::Error:
    default: { 
      mout.error("IS Attribute Error " ); 
      break; 
    }
    }
      }
      catch(seal::Exception &e){
    std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
    exit( 1 );
      }
      catch(std::exception &e){
    std::cerr << "Standard exception caught[" << e.what() << "]" << std::endl;
    exit(1);
      }
      catch(...) {
    std::cerr << "Unknow exception caught. proceeding data from ISInfoAny to AttributeList" << std::endl;
    exit (1);
      }
  }
  

   // Now we have the table with the the values in memmory,
   // Lets assign an interval of validity to the rows in the table

  // the time of publishing of this information into the IS
  // will be the since

  //the till will be +Inf
  OWLTime t = isa.time();
  
  // the time is in seconds...need to convert to nanoseconds
#ifdef DEBUG
  std::ostringstream msg, msg2;
  cool::ValidityKey since = t.c_time();
  msg << "[SINCE] = [" << since << "] [TILL] = [" << cool::ValidityKeyMax << "]" << std::endl;
  mout.verbose( msg.str());
  since = since * 1000000000;
  msg2 << "After transformation to nanoseconds : [SINCE] = [" << since << "] [TILL] = [" << cool::ValidityKeyMax << "]" << std::endl;
  mout.verbose( msg2.str());
#else
  cool::ValidityKey since = t.c_time();
  // the fantastic convertion to nanoseconds.. :-D
  since = since * 1000000000;
#endif
  cool::ValidityKey till  = cool::ValidityKeyMax;

  
  
  mout.info("<cdiCOOLDataHandle::process_data> Proceeding to data storage ...", 0);
  
  // Let's get the folder from the manager
  
  std::string folder( "/TDAQ/" + partition.name() + "/" + foldName);
  m_fld = m_db->getFolder( folder );
  
  try {
    mout.debug(std::string("Storing object in [" + folder + "]"));
    std::ostringstream msg;
    msg << "Object IOV : [" << since << "|" << till << "]";
    mout.verbose(msg.str());

#ifdef DEBUG    
    mout.verbose("Dumping the AttrList that will be stored");
    std::ostringstream attstr;
    pList.print(attstr);
    mout.verbose(attstr.str());
#endif

    mout.verbose("Going to store the AttributeList");
    // since we don't need channel ID we will use always channel id=1 
    m_fld->storeObject( since, till, pList, 1);
    mout.verbose("Storing done");
  }
  catch(seal::Exception &e){
    std::cerr << "SEAL exception caught [" << e.code() << "] : " << e.message() << std::endl;
    exit( 1 );
  }
  catch(...) {
    std::cerr << "Unknow exception caught procedding data from ISInfoAny to AttributeList" << std::endl;
    exit( 1 );
  }
  mout.info("<cdiCOOLDataHandle::writeData> Object stored successfully",0);
}

---