cdiDataHandle.cxx

//*************************************************************************************
//
//   cdiDataHandle.cxx
//   ----------
//   Implementation of the cdiDataHandle class.
//   
//   Luis Pedro     -  November 2003
//   Sergei Kolos   -  May 2004
//   Dinis Klose    -  July 2004
//   Nuno Barros    -  September 2004
//
/*************************************************************************************/

// STD includes
#include <sstream>
#include <algorithm>
#include <cstdlib>
#include <iostream>
extern "C" {
#include <unistd.h>
};

// CDI specific includes
#include "cdi/cdiDataHandle.h"
#include "cdi/cdiAux.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>

const std::string cdiDataHandle::configuration_name = "RunParams.Conditions";

template <class T>
void convert( ISInfoAny & isa, std::vector<std::string> & to )
{
    if ( isa.isAttributeArray() )
    {
    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() );
    }
}

void convertTime ( ISInfoAny & isa, std::vector<std::string> & to )
{
     if ( isa.isAttributeArray() )
     {
         std::vector<OWLTime> val;
         isa >> val;
         for ( size_t i = 0; i < val.size() ; i++ )
         {
             OWLTime t = val[i];
             long unixTime = t.c_time();
             std::ostringstream out;
             out << unixTime;
             to.push_back( out.str() );
         }
     }
     else
     {
        OWLTime t;
    isa >> t;
        long unixTime = t.c_time();
        std::ostringstream out;
        out << unixTime;
        to.push_back( out.str() );
     }      
}   

void cdiDataHandle::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 objeccts 
  Conditions conditions;
  ISInfo::Status status = dictionary.findValue( configuration_name.c_str(), conditions );
  
  mout.info( std::string("Getting Informations to subscribe"), 2);
  
  names.clear();
  
  if ( status == ISInfo::Success)
    names = conditions.isservers;

  // The RunParams.RunParams object ismandatory
  if ( std::find( names.begin(), names.end(), std::string( "RunParams.RunParams" ) ) == names.end() ) {
    mout.info( std::string("cdiDataHandle::getConfig> Adding [RunParams.RunParams] to names"),3);
    names.push_back( "RunParams.RunParams" );
  }
 
  //The RunParams.Conditions 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.info( std::string("cdiDataHandle::getConfig> Adding [" + configuration_name+ "] to names"),3);
    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

  
  //  std::vector<std::string>::const_iterator it = names.begin();
  std::vector<std::string>::const_iterator itEnd = names.end();

  // 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 sever [" + objName + "]"));
    
    ISInfoIterator ii(partition,ISit.name());
    while( ii() ){
      // let's finally iterate under all the subscribed names from the user
      //objName += ".";
      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) + "]"));
      pNames.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("getConfig -> [" + objName + "] does not match the expression [" + (*it) + "]"));
    }
    
      }
    }
  }
    mout.info( std::string("cdiDataHandle::getConfig> Returning without problems"),3);
}

std::string cdiDataHandle::getProfile()
{
    char * tmp = getenv( "TDAQ_COND_DB_PROFILE" );
  
    if ( tmp == 0 )
    {
    mout.info( std::string("Environment variable TDAQ_COND_DB_PROFILE must be defined!") );
    mout.info( std::string("CDI will exit now.") );
    exit(1);
    }
    
    return std::string(tmp);
}

cdiDataHandle::cdiDataHandle( int verbosity, const IPCPartition & p )
  : partition( p ),
    mout( verbosity )
{
  mout.info(std::string("Initializing CDI Data Handle.."), 3);
 
  // Simple types
  types.insert( std::make_pair( ISType::Boolean,    ICondDBTable::cdbBool ) );
  types.insert( std::make_pair( ISType::S16,    ICondDBTable::cdbInt ) );
  types.insert( std::make_pair( ISType::U16,    ICondDBTable::cdbInt ) );
  types.insert( std::make_pair( ISType::S32,    ICondDBTable::cdbLongLong ) );
  types.insert( std::make_pair( ISType::U32,    ICondDBTable::cdbLongLong ) );
  types.insert( std::make_pair( ISType::Float,  ICondDBTable::cdbFloat ) );
  types.insert( std::make_pair( ISType::Double, ICondDBTable::cdbDouble ) );
  types.insert( std::make_pair( ISType::S8, ICondDBTable::cdbString ) );
  types.insert( std::make_pair( ISType::U8, ICondDBTable::cdbString ) );
  types.insert( std::make_pair( ISType::String, ICondDBTable::cdbString ) );
  types.insert( std::make_pair( ISType::Date,   ICondDBTable::cdbLongLong ) );
  types.insert( std::make_pair( ISType::Time,   ICondDBTable::cdbLongLong ) );
  
  // Array types
  a_types.insert( std::make_pair( ISType::Boolean,  ICondDBTable::cdbArrayBool ) );
  a_types.insert( std::make_pair( ISType::S16,  ICondDBTable::cdbArrayInt ) );
  a_types.insert( std::make_pair( ISType::U16,  ICondDBTable::cdbArrayInt ) );
  a_types.insert( std::make_pair( ISType::S32,  ICondDBTable::cdbArrayLongLong ) );
  a_types.insert( std::make_pair( ISType::U32,  ICondDBTable::cdbArrayLongLong ) );
  a_types.insert( std::make_pair( ISType::Float,    ICondDBTable::cdbArrayFloat ) );
  a_types.insert( std::make_pair( ISType::Double,   ICondDBTable::cdbArrayDouble ) );
  a_types.insert( std::make_pair( ISType::S8,   ICondDBTable::cdbArrayString ) );
  a_types.insert( std::make_pair( ISType::U8,   ICondDBTable::cdbArrayString ) );
  a_types.insert( std::make_pair( ISType::String,   ICondDBTable::cdbArrayString ) );
  a_types.insert( std::make_pair( ISType::Date, ICondDBTable::cdbArrayLongLong ) );
  a_types.insert( std::make_pair( ISType::Time, ICondDBTable::cdbArrayLongLong ) );
  
  
  try
  {
    init( getProfile() );
  }
  catch (CondDBException &e)
  {
    std::cerr  << e.getMessage() << "   " << e.getErrorCode() << std::endl;
    exit( 1 );
  }
}

void cdiDataHandle::init( const std::string & profile )
{
  mout.info(std::string("Initializing ConditionsDB Objects.."), 3); 
  
  mout.info(std::string("Performing CondDBMySQLMgrFactory::createCondDBMgr..."), 3);
  condDBmgr = CondDBMySQLMgrFactory::createCondDBMgr();
  
  mout.info(std::string("Performing condDBmgr->init()"), 3);
  condDBmgr->init(profile);
  
  mout.info(std::string("Performing condDBMgr->createCondDB()"), 3);
  condDBmgr->createCondDB();
  
  mout.info(std::string("Performing condDBMgr->openDatabase()"), 3);
  condDBmgr->openDatabase();
  
  mout.info(std::string("Performing condDBMgr-getCondDBDataAccess()"), 3);
  condDataAccess = condDBmgr->getCondDBDataAccess();
  
  mout.info(std::string("Performing condDBMgr->getCondDBFolderMgr()"), 3);
  condFolderMgr  = condDBmgr->getCondDBFolderMgr(); 
}

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

void cdiDataHandle::add_table ( ICondDBTable * table, const std::string & name )
{
  mout.info(std::string("Entering <cdiDataHandle::add_table>"), 2);
  table->resize( 1 );
  tables.insert( std::make_pair( name, table ) );
}

void cdiDataHandle::create_folder ( const std::string & name, ISInfoAny & isa )
{  
  mout.info( std::string( "Entering <cdiDataHandle::create_folder> " + name ), 2 );

  if ( is_table_exist( name ) )
  {
    mout.info(std::string("Entering <cdiDataHandle::create_folder> Folder already exist"), 3);
    return;
  }
  
  ICondDBTable * table = CondDBMySQLTableFactory::createCondDBTable();
  
  std::string fname = std::string("/tdaq/" + partition.name() + "/" + name);
  
  try
  {
    condDataAccess->getTableSchema( fname, table );
    add_table( table, name );
    mout.info(std::string("<cdiDataHandle::create_folder> Read table schema from the database") );
    return;
  }
  catch (CondDBException &e)
  {
    mout.info( std::string("<cdiDataHandle::create_folder> Folder does not exist in the database "), 1 );
  }
  
  table->Initialize( isa.countAttributes() );
  
  ISInfoDocument isd( partition, isa );
  
  if ( isd.status() == ISInfo::Success )
  {
    mout.info(std::string("<cdiDataHandle::create_folder> isd.name: " + isd.name() + " isd.description: " + isd.description() ) , 3 );
  }
  else
  {
    if (isd.status() == ISInfo::CommFailure) {
      mout.error(std::string("<cdiDataHandle::create_folder> The IS types descriptions repository is not available"));
      // exit (0);
    }
    else {
      mout.info(std::string("<cdiDataHandle::create_folder> IS description for the " + isd.name() + " is not available" ) , 3 );
      // exit(0);
    }
  }
  
  for ( size_t i = 0; i < isa.countAttributes(); i++ )
    {
      // nbarros - just a small try
      const ISInfoDocument::Attribute *attr = 0;
      if (isd.status() == ISInfo::Success) {
    attr = isd.attribute( i );
      }
      table->setType( i, isa.isAttributeArray() ? a_types[isa.getAttributeType()] 
              : types[isa.getAttributeType()] );
      std::ostringstream out;
      out << "column_" << i;
      table->setName( i, attr ? attr->name() : out.str() ); 
      
      std::ostringstream msg, msg2;
      //let's put the data in the payloadSpec
      //      msg << "Attribute name: [" << attr->name() << "] Attribute type: [" 
      //      <<  types[isa.getAttributeType()] << "] <-> [" << isa.getAttributeType()
      //      << "]"; 
      //mout.verbose(msg.str());
      
      std::vector<std::string> cell;
      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<string>( isa, cell ); break; }
    case ISType::Date: { convertTime( isa, cell ); break; }
    case ISType::Time: { convertTime( isa, cell ); break; }
    case ISType::Error:
    default: { mout.info( string( "IS Attribute Error " ) ); break; }
      }

  }
   
  isa.reset();

  try
  {
    //Creating the folder in the database
    mout.info(std::string("<cdiDataHandle::create_folder> Proceeding to folder " + name + " creation (if needed)... ") , 3);
        
    if ( !condFolderMgr->exist( fname ) )
    {
    mout.info( std::string("<cdiDataHandle::create_folder> folder " + fname + " does not exist " ) );
    condFolderMgr->createCondDBFolder( fname, table, "", "", true );
    mout.info(std::string("<cdiDataHandle::create_folder> Folder " + fname + " created." ) );
    }
    else
    {
    mout.info(std::string("<cdiDataHandle::create_folder> Folder " + fname + " already exists.") );
    }
    add_table( table, name );
  }
  catch (CondDBException &e)
  {
    mout.error( std::string(" ConditionsDB exception : " + (std::string)e.getMessage() ) );
  }
}

void cdiDataHandle::process_data ( const std::string & name, ISCallbackInfo * isc )
{
  mout.info(std::string("Entering <cdiDataHandle::process_data>"), 2);
  ISInfoAny isa;
  isc->value( isa );



  std::string rVersion = RELEASE_NAME;
  std::string fSuffix;
  std::string::size_type beg = rVersion.find("-");
  
  if (beg != std::string::npos) // there is a version name
    fSuffix = rVersion.substr(beg);
  else // the cmtrealease is a nighlty
    fSuffix = "-" + rVersion;
  
  std::string foldName = name + fSuffix; //"-01-00-00"; 
  
  create_folder ( foldName, isa );
  
  // fianlly process to object storage
  storeObject( name, isa);
}


void cdiDataHandle::storeObject( const std::string& name, ISInfoAny &isa) {
  
  
  std::string rVersion = RELEASE_NAME;
  std::string fSuffix;
  std::string::size_type beg = rVersion.find("-");
  
  if (beg != std::string::npos) // there is a version name
    fSuffix = rVersion.substr(beg);
  else // the cmtrealease is a nighlty
    fSuffix = "-" + rVersion;
  
  std::string foldName = name + fSuffix; //"-01-00-00"; 

  create_folder ( foldName, isa );
  
  ICondDBTable * table = tables[foldName];
  
  if ( !table )
  {
    mout.error(std::string("<cdiDataHandle::writeData> table " + name + " does not exist") );
    return;
  }
    
  mout.info(std::string("<cdiDataHandle::writeData> processing data with structure description"), 2);
    
  for( size_t n = 0; n < isa.countAttributes(); n++ )
  {
      std::vector<std::string> cell;
      bool is_array = isa.isAttributeArray();
      switch ( isa.getAttributeType() )
      {
    case ISType::Boolean: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "bool" << "]" ;
      mout.verbose(msg.str());
      convert<bool>( isa, cell ); break; }
    case ISType::S16: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "S16" << "]" ;
      mout.verbose(msg.str());
      convert<short>( isa, cell ); break; }
    case ISType::U16: {       std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "U16" << "]" ;
      mout.verbose(msg.str());
      convert<unsigned short>( isa, cell ); break; }
    case ISType::S32: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "S32" << "]" ;
      mout.verbose(msg.str());
      convert<long>( isa, cell ); break; }
    case ISType::U32: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "U32" << "]" ;
      mout.verbose(msg.str());
      convert<unsigned long>( isa, cell ); break; }
    case ISType::Float: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "FLoat" << "]" ;
      mout.verbose(msg.str());
      convert<float>( isa, cell ); break; }
    case ISType::Double: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "Double" << "]" ;
      mout.verbose(msg.str());
      convert<double>( isa, cell ); break; }
    case ISType::S8: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "S8" << "]" ;
      mout.verbose(msg.str());
      convert<char>( isa, cell ); break; }
    case ISType::U8: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "U8" << "]" ;
      mout.verbose(msg.str());
      convert<unsigned char>( isa, cell ); break; }
    case ISType::String: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "String" << "]" ;
      mout.verbose(msg.str());
      convert<string>( isa, cell ); break; }
    case ISType::Date: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "Date" << "]" ;
      mout.verbose(msg.str());
      convertTime( isa, cell ); break; }
    case ISType::Time: { 
      std::ostringstream msg;
      msg << "Parameter [" << n << "]: ["
          << "Time" << "]" ;
      mout.verbose(msg.str());
      convertTime( isa, cell ); break; }
    case ISType::Error:
    default: { mout.info( string( "IS Attribute Error " ) ); break; }
      }

      try
      {
    if ( is_array )
      table->setCell( n, 0, cell );
    else
      table->setCell( n, 0, cell[0] );
      }
      catch (CondDBException &e)
      {
    std::cerr << e.getMessage() << " " << e.getErrorCode() << std::endl; 
      }
  }  
  // Now we have the table with the the values in memmory,
  // Lets assign an interval of validity to the rows in the table
      
  OWLTime t = isa.time();

  SimpleTime since ( t.c_time() );
  SimpleTime till;
  till.setPlusInf();
    
  table->changeSinceTime( 0, since );
  table->changeTillTime( 0, till );
  
  mout.info(std::string("<cdiDataHandle::writeData> Storing Table ...") );

  std::string folder( "/tdaq/" + partition.name() + "/" + foldName);
  
  try
  {
    condDataAccess->storeCondDBObject( folder, table );
  }
  catch (CondDBException &e)
  {
    std::cerr << e.getMessage() << " " << e.getErrorCode() << std::endl; 
  }
  
  mout.info(std::string("<cdiDataHandle::writeData> Table stored") );
}

---