cdi_ls_cool.cxx

#include <iostream>
#include <vector>
#include <string>

// Other standard C includes
extern "C" {
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <signal.h>
};

// some cclasses needed to store data
#include "ipc/core.h"
#include <ipc/partition.h>
#include "cdi/cdiHandle.h"

// The objects to be stored
#include "rc/Conditions.h"
#include "rc/RunParams.h"

// COOL includes
// This application goes directly into COOL
#include <sstream>
#include <string>
#include "AttributeList/AttributeList.h"
#include "CoolApplication/DatabaseSvcFactory.h"
#include "CoolKernel/DatabaseId.h"
#include "CoolKernel/IDatabase.h"
#include "CoolKernel/IDatabaseSvc.h"
#include "CoolKernel/IFolder.h"
#include "CoolKernel/IObject.h"
#include "CoolKernel/IObjectIterator.h"
#include "SealKernel/Exception.h"
#include "SealBase/TimeInfo.h"
//#include "src/timeToString.h"
//#include "src/uppercaseString.h"


bool validEnvironment(std::string &msg ){
  
  msg = "The environment variable ";

  char* st = getenv("SEAL_KEEP_MODULES");
  if (st == NULL){
    msg = " \'SEAL_KEEP_MODULES\' is not set!";
    return false;
  }
  
  st = getenv("SEAL_PLUGINS");
  if (st == NULL){
    msg = " \'SEAL_PLUGINS\' is not set!";
    return false;
  }

  //  if (option == 1) {
    st = getenv("TDAQ_COOL_PROFILE");
    if (st == NULL){
      msg = " \'TDAQ_COOL_PROFILE\' is not set!";
      return false;
    }
    /*
  }
  else{
    st = getenv("TDAQ_COND_DB_PROFILE");
    if (st == NULL){
      msg = " \'TDAQ_COND_DB_PROFILE\' is not set!";
      return false;
    }
  }
    */
    return true;
}

void printUsage(){
  std::cout << "Usage: cdi_ls_cool -p partition [-r release] [-s ISServer.IsObject]" 
        << std::endl << std::endl;
  std::cout << "       By default it connects to release \'nightly\' and object \'RunParams.RunParams\'" 
        << std::endl;

  exit(EXIT_SUCCESS);
}

void parseArgs(int &argc,char**&argv,std::string &release,std::string &obj,std::string &partition){
  // let's parse the arguments
  // at least 3 arguments must be given...and we should not have more than 7
  if (argc < 3 || argc > 7){
    printUsage();
  }
  else{
    // just the odd indexes have the parameters choosen
    for (int i=1; i< argc; i+=2){
      std::string arg(argv[i]);
      // The user can ask for help
      if (arg == "-h" || arg == "--help"){
    printUsage();
      }
      
      if (arg != "-p" && arg != "-r" && arg != "-s" && arg != "--partition" && arg != "--release" && arg != "--object"){
    std::cerr << "Bad option \'" << arg << "\'" << std::endl;
    printUsage();
      }
      else{
    if (arg == "-p" || arg == "--partition"){
      // defining the partition
      std::cout << "::parseArgs : Using partition [" << argv[i+1] << "]" << std::endl;
      partition = argv[i+1];
    }
    else{
      if (arg == "-r" || arg == "--release"){
        std::cout << "::parseArgs : Using release [" << argv[i+1] << "]" << std::endl;
        release = argv[i+1];
      }
      else{
        if (arg == "-s" || arg == "--object"){
          std::cout << "::parseArgs : Checking object [" <<  argv[i+1] << "]" << std::endl;
          obj = argv[i+1];
        }
        else {
          std::cerr << "::parseArgs : There was a problemparsing the arguments" << std::endl;
        }
      }
    }
      }
    }
    
    // if, after parsing, the partition is still undefined, we need to get out
    if (!(partition.length())){
      std::cerr << "::main:ERROR : partition not defined." << std::endl;
      exit(EXIT_FAILURE);
    }
    
  }
  
}

int main(int argc, char ** argv){
  
  int status = EXIT_SUCCESS;
  
  std::string msg;
  std::string folder;
  std::string release = "nightly", obj = "RunParams.RunParams", partition = "";


  // the ffirst thing to do is to check the number of arguments and the environment

  // let's check the environment
  if (!validEnvironment(msg)){
    std::cerr << "::main : The environmanet check failed:-> " << msg << std::endl;
    exit(1);
  }
 
  // let's parse the arguments given
  parseArgs(argc,argv,release,obj,partition);
  
  // From now n let's start the real work.
  // we are going to use the TDAQ_COOL_PROFILE env to knwo where to connect
  
  try {
    
    std::cout << "::main : Get a handle to the COOL database service" << std::endl;
    cool::IDatabaseSvc& dbSvc = cool::DatabaseSvcFactory::databaseService();
    
    //------------------------
    // DEFINE THE DATABASE ID
    //------------------------

    cool::DatabaseId dbId = getenv("TDAQ_COOL_PROFILE");
    
    //---------------------------
    // OPEN AN EXISTING DATABASE
    //---------------------------

    // Open an existing COOL conditions database
    // Since this is a reading tool, for sure that 
    // the database will exist
    std::cout << "::main : " << "Open an existing conditions database: " << dbId << std::endl;
    cool::IDatabasePtr db = dbSvc.openDatabase( dbId );
    std::cout << "::main : " << "Conditions database opened: " << std::endl;

    //----------------------------
    // GENERATING THE FOLDER NAME
    //----------------------------

    // let's build the folder name
    std::string folderName = "/TDAQ/" + partition + "/" + obj + "-" + release;
    std::cout << "::main : Checking folder [" << folderName << "]" << std::endl;
    
    cool::IFolderPtr folder = db->getFolder( folderName );
    
    //------------------
    // OBJECT RETRIEVAL
    //------------------

    // Bulk-retrieve the objects stored in channel 1 of folder in the last 5 min [now() - 5,now()]
    std::cout << "::main : Checking the data of the last 5 minutes" << std::endl;

    // Why a tag? In online mode we don't use tags
    //    std::string tag = "";
    
    cool::ChannelId channelId = 1;
    // the time is stored as the number of nanoseconds 
    // since the 1/1/1970
    // the function time returns the number of seconds
    // then I need to multiply that value by 10^9
    cool::ValidityKey until =(cool::ValidityKey)( time(NULL));
    until *= 1000000000;  
    cool::ValidityKey since = until;
    since -= 300000000000;

    std::cout << "::main : Browsing data for intervals [" << since 
          << "|" << until << "]" << std::endl;
    
    // Let's go for the object browsing
    cool::IObjectIteratorPtr objIt = folder->browseObjects( since, until, channelId, "" );

    std::cout << "::main : " << "Retrieved object iterator for folder "
          << folder->fullPath() << std::endl;
    
    if ( objIt->isEmpty() ) {
      std::cout << "::main : " << "Iterator contains no objects" << std::endl;
    } else {

      // let's print the data as a table
      // we don't know the object structure right now...so let's get the AttributeListSpecification
      // which has all the information needed
      pool::AttributeListSpecification payloadSpec = folder->payloadSpecification();
      
      /*
      //let's print the names and types of the data in the object
      std::cout << "[\'channelId\'\t][\'SINCE\'\t][\'UNTIL\'\t]";
      for (size_t i = 0; i< payloadSpec.size(); i++){
      std::string name = payloadSpec[i].name();
      std::cout << "[\'" << name << "\'\t]";
      }
      std::cout << std::endl;
      */
      
      // Let's now print the data
      // Let's go for the beggining of the iterator
      objIt->goToStart();
      while( objIt->hasNext() ) {
        cool::IObjectPtr object = objIt->next();
        std::cout << "[\'channelID\'] = [" << object->channelId() << "]\n"
          << "[  \'SINCE\'  ] = [" << object->since() << "]\n"
          << "[  \'UNTIL\'  ] = ["<< object->until() << "]\n"; //<< std::endl;
      
    //  std::cout << "::main : " << "Object: payload values : " << std::endl;
    
    // Since we don't know the structure of the object stored let's
    // use the payloadSpec to see it
    for (size_t i = 0; i< payloadSpec.size(); i++){
      std::string name = payloadSpec[i].name();
      std::cout << "[\'" << name << "\'] = [" << object->payloadValue(name)  << "]" << std::endl;
      //      std::cout << "[" << object->payloadValue(name)  << "\t]";
    }
    std::cout << std::endl;
    
        if( ! object->isStored() ) {
          std::cout << " ::main : " << "Object: isStored=false" << std::endl;
        } else {
          std::cout << " ::main : " << "Object: isStored=true, insertionTime=" 
            << object->insertionTime()  << std::endl;
        }
      } 
    }
    

  }

  catch(seal::Exception& se) 
    {
      std::cerr << "::main : ERROR! Seal Exception: '" << se << "'" << std::endl;
      status =  EXIT_FAILURE;
    }
  catch(std::exception& e)
    {
      std::cerr << "::main : ERROR! Standard C++ exception: '" << e.what() << "'" << std::endl;
      status = EXIT_FAILURE;
    }
  catch(...) 
    {
      std::cerr << "::main : ERROR! Unknown exception caught" << std::endl;
      status = EXIT_FAILURE;
    }
  
  // if everything went ok up to now. It is safe to exit with status
  return status;
}

---