ConfigurationDatabaseImplOracle.cc

Go to the documentation of this file.

#include "CaloOnlineTools/HcalOnlineDb/interface/ConfigurationDatabaseImplOracle.hh"
#include <iostream>  // std::cout

#ifdef HAVE_XDAQ
#include <toolbox/string.h>
#else
#include "CaloOnlineTools/HcalOnlineDb/interface/xdaq_compat.h"  // Replaces toolbox::toString
#endif

using namespace std;
using namespace oracle::occi;
using namespace hcal;
//
// provides factory method for instantion of ConfigurationDatabaseImplOracle application
//
DECLARE_PLUGGABLE(hcal::ConfigurationDatabaseImpl,ConfigurationDatabaseImplOracle)

ConfigurationDatabaseImplOracle::ConfigurationDatabaseImplOracle()
{

}

bool ConfigurationDatabaseImplOracle::canHandleMethod(const std::string& method) const {
  return (method=="occi");
}

ConfigurationDatabaseImplOracle::~ConfigurationDatabaseImplOracle() {
    disconnect();

}

void ConfigurationDatabaseImplOracle::connect(const std::string& accessor) noexcept(false) {
  std::map<std::string,std::string> params;
  std::string user, host, method, db, port,password;
  ConfigurationDatabaseImpl::parseAccessor(accessor,method,host,port,user,db,params);

  if (method!="occi") XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,std::string("Invalid accessor for Oracle : ")+accessor);

  if (params.find("PASSWORD")!=params.end()) password=params["PASSWORD"];
  if (params.find("LHWM_VERSION")!=params.end()) lhwm_version=params["LHWM_VERSION"];

  try {
     env_ = oracle::occi::Environment::createEnvironment (oracle::occi::Environment::DEFAULT);
     conn_ = env_->createConnection (user, password, db);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }


  if (env_ == nullptr || conn_ == nullptr) {
    std::string message("Error connecting on accessor '");
    message+=accessor;
    XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,message);
  }
}

void ConfigurationDatabaseImplOracle::disconnect() {

   try {
        //terminate environment and connection
        env_->terminateConnection(conn_);
        Environment::terminateEnvironment(env_);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }


}

//Utility function that cnverts oracle::occi::Clob to std::string
string ConfigurationDatabaseImplOracle::clobToString(const oracle::occi::Clob& _clob){
        oracle::occi::Clob clob = _clob;
                Stream *instream = clob.getStream (1,0);
        unsigned int size = clob.length();
                char *cbuffer = new char[size];
                memset (cbuffer, 0, size);
                instream->readBuffer (cbuffer, size);
                std::string str(cbuffer,size);
        return str;
}
//inline function to convert hex2integer
inline static int cvtChar(int c) {
  if (c>='0' && c<='9') c-='0';
  if ((c>='a' && c<='f')||(c>='A' && c<='F')) c-='A'+10;
  return c&0xF;
}

void ConfigurationDatabaseImplOracle::getLUTChecksums(const std::string& tag,
        std::map<hcal::ConfigurationDatabase::LUTId,
        hcal::ConfigurationDatabase::MD5Fingerprint>& checksums) noexcept(false) {

    if (env_ == nullptr || conn_ == nullptr) XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Database is not open");
    checksums.clear();

   try {
        Statement* stmt = conn_->createStatement();

        std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_TRIG_LOOKUP_TABLES");
        query+=" WHERE CRATE=-1";
        //query+=toolbox::toString(" WHERE TAG_NAME='%s' CRATE=-1", tag.c_str());

        //SELECT
        ResultSet *rs = stmt->executeQuery(query);

        while (rs->next()) {
                oracle::occi::Clob clob = rs->getClob (1);
                std::list<ConfigurationDatabaseStandardXMLParser::Item> items;
                std::string buffer = clobToString(clob);

                m_parser.parseMultiple(buffer,items);

                for (std::list<ConfigurationDatabaseStandardXMLParser::Item>::iterator i=items.begin(); i!=items.end(); ++i) {

                        hcal::ConfigurationDatabase::FPGASelection ifpga =
                (hcal::ConfigurationDatabase::FPGASelection)atoi(i->parameters["topbottom"].c_str());
                        int islot = atoi(i->parameters["slot"].c_str());
            hcal::ConfigurationDatabase::LUTType ilut_type =
                (hcal::ConfigurationDatabase::LUTType)atoi(i->parameters["luttype"].c_str());
            int crate=atoi(i->parameters["crate"].c_str());
                        int islb=atoi(i->parameters["slb"].c_str());
                        int islbch=atoi(i->parameters["slbchan"].c_str());
            hcal::ConfigurationDatabase::LUTId lut_id;
                        lut_id=hcal::ConfigurationDatabase::LUTId(crate, islot, ifpga, islb, islbch, ilut_type);

            hcal::ConfigurationDatabase::MD5Fingerprint csum(16);
            std::string encoded = (std::string)i->items[0];
            for (int i=0; i<16; i++) {
                //converting hex2integer
                csum[i]=cvtChar(encoded[i*2])*16+cvtChar(encoded[i*2+1]);
            }

            checksums[lut_id]=csum;
        }
    }
        //Always terminate statement
        conn_->terminateStatement(stmt);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }

}

void ConfigurationDatabaseImplOracle::getLUTs(const std::string& tag, int crate, int slot, std::map<hcal::ConfigurationDatabase::LUTId, hcal::ConfigurationDatabase::LUT >& LUTs) noexcept(false) {
  if (m_lutCache.crate!=crate || m_lutCache.tag!=tag) {
    m_lutCache.clear();
    getLUTs_real(tag,crate,m_lutCache.luts);
    m_lutCache.crate=crate;
    m_lutCache.tag=tag;
  }

  LUTs.clear();
  std::map<hcal::ConfigurationDatabase::LUTId, hcal::ConfigurationDatabase::LUT >::const_iterator i;
  for (i=m_lutCache.luts.begin(); i!=m_lutCache.luts.end(); i++) {
    if (i->first.slot==slot)
      LUTs.insert(*i);
  }
}


void ConfigurationDatabaseImplOracle::getLUTs_real(const std::string& tag, int crate,
            std::map<hcal::ConfigurationDatabase::LUTId, hcal::ConfigurationDatabase::LUT >& LUTs)
                                noexcept(false)
{

   try {
    //Lets run the SQl Query
    Statement* stmt = conn_->createStatement();

    std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_TRIG_LOOKUP_TABLES");
    query+=toolbox::toString(" WHERE TAG_NAME='%s' AND CRATE=%d", tag.c_str(), crate);

    //SELECT
        ResultSet *rs = stmt->executeQuery(query);

    LUTs.clear();

    while (rs->next()) {
        oracle::occi::Clob clob = rs->getClob (1);
        std::list<ConfigurationDatabaseStandardXMLParser::Item> items;
        std::string buffer = clobToString(clob);
        m_parser.parseMultiple(buffer,items);

            for (std::list<ConfigurationDatabaseStandardXMLParser::Item>::iterator i=items.begin(); i!=items.end(); ++i) {
            hcal::ConfigurationDatabase::FPGASelection ifpga =
                    (hcal::ConfigurationDatabase::FPGASelection)atoi(i->parameters["TOPBOTTOM"].c_str());
            int islot = atoi(i->parameters["SLOT"].c_str());

            //If this is the desired slot
            //if (islot == slot) {
                hcal::ConfigurationDatabase::LUTType ilut_type =
                        (hcal::ConfigurationDatabase::LUTType)atoi(i->parameters["LUT_TYPE"].c_str());
                hcal::ConfigurationDatabase::LUTId lut_id;
                    if (ilut_type==hcal::ConfigurationDatabase::LinearizerLUT) {
                    int ifiber=atoi(i->parameters["FIBER"].c_str());
                    int ifiberch=atoi(i->parameters["FIBERCHAN"].c_str());
                    lut_id=hcal::ConfigurationDatabase::LUTId(crate, islot, ifpga, ifiber, ifiberch, ilut_type);
                } else {
                    int islb=atoi(i->parameters["SLB"].c_str());
                    int islbch=atoi(i->parameters["SLBCHAN"].c_str());
                    lut_id=hcal::ConfigurationDatabase::LUTId(crate, islot, ifpga, islb, islbch, ilut_type);
                }

                hcal::ConfigurationDatabase::LUT lut;
                lut.reserve(i->items.size());

                int strtol_base=0;
                if (i->encoding=="hex") strtol_base=16;
                else if (i->encoding=="dec") strtol_base=10;

                // convert the data
                for (unsigned int j=0; j<i->items.size(); j++)
                    lut.push_back(strtol(i->items[j].c_str(),nullptr,strtol_base));

                LUTs.insert(make_pair(lut_id, lut));
            //}
            }
    }

    //Always terminate statement
    conn_->terminateStatement(stmt);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }

}

void ConfigurationDatabaseImplOracle::getPatterns(const std::string& tag, int crate, int slot, std::map<hcal::ConfigurationDatabase::PatternId, hcal::ConfigurationDatabase::HTRPattern >& patterns) noexcept(false) {
  if (m_patternCache.crate!=crate || m_patternCache.tag!=tag) {
    m_patternCache.clear();
    getPatterns_real(tag,crate,m_patternCache.patterns);
    m_patternCache.crate=crate;
    m_patternCache.tag=tag;
  }

  patterns.clear();
  std::map<hcal::ConfigurationDatabase::PatternId, hcal::ConfigurationDatabase::HTRPattern >::const_iterator i;
  for (i=m_patternCache.patterns.begin(); i!=m_patternCache.patterns.end(); i++) {
    if (i->first.slot==slot)
      patterns.insert(*i);
  }
}

void ConfigurationDatabaseImplOracle::getPatterns_real(const std::string& tag, int crate,
            std::map<hcal::ConfigurationDatabase::PatternId, hcal::ConfigurationDatabase::HTRPattern >& patterns)
                            noexcept(false) {
   try {
        //Lets run the SQl Query
        Statement* stmt = conn_->createStatement();

        std::string query = ("SELECT HTR_DATA_PATTERNS_DATA_CLOB FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_HTR_DATA_PATTERNS");
        query+=toolbox::toString(" WHERE TAG_NAME='%s' AND CRATE=%d", tag.c_str(), crate);

        //SELECT
        ResultSet *rs = stmt->executeQuery(query);

        patterns.clear();

        while (rs->next()) {
                oracle::occi::Clob clob = rs->getClob (1);
                std::list<ConfigurationDatabaseStandardXMLParser::Item> items;
                std::string buffer = clobToString(clob);

                m_parser.parseMultiple(buffer,items);

                for (std::list<ConfigurationDatabaseStandardXMLParser::Item>::iterator i=items.begin(); i!=items.end(); ++i) {
                        int islot=atoi(i->parameters["SLOT"].c_str());
                        //If this is the desired slot
                        //if (islot == slot) {
                                hcal::ConfigurationDatabase::FPGASelection ifpga =
                    (hcal::ConfigurationDatabase::FPGASelection)atoi(i->parameters["TOPBOTTOM"].c_str());
                                int ifiber=atoi(i->parameters["FIBER"].c_str());

                                hcal::ConfigurationDatabase::PatternId pat_id(crate, islot, ifpga, ifiber);
                                hcal::ConfigurationDatabase::HTRPattern& pat=patterns[pat_id];
                                pat.reserve(i->items.size());

                                int strtol_base=0;
                                if (i->encoding=="hex") strtol_base=16;
                                else if (i->encoding=="dec") strtol_base=10;

                                // convert the data
                                for (unsigned int j=0; j<i->items.size(); j++)
                                        pat.push_back(strtol(i->items[j].c_str(),nullptr,strtol_base));
                        //}
                }
        }
        //Always terminate statement
        conn_->terminateStatement(stmt);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }


}

void ConfigurationDatabaseImplOracle::getRBXdata(const std::string& tag, const std::string& rbx,
                        hcal::ConfigurationDatabase::RBXdatumType dtype,
                        std::map<ConfigurationDatabase::RBXdatumId, hcal::ConfigurationDatabase::RBXdatum>& RBXdata)
                        noexcept(false) {

        RBXdata.clear();

        Statement* stmt = conn_->createStatement();
        std::string query;

        //std::string datatypestr;
        switch (dtype) {

                case (ConfigurationDatabase::eRBXpedestal):
                        //datatypestr="PEDESTAL";

                        //Lets run the SQl Query
                        query  = "SELECT MODULE_POSITION, QIE_CARD_POSITION, QIE_ADC_NUMBER, INTEGER_VALUE ";
                        query += " FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_RBX_PEDESTAL_CONFIG ";
                        query += toolbox::toString(" WHERE TAG_NAME='%s' AND NAME_LABEL='%s'", tag.c_str(), rbx.c_str());

                        break;

                case (ConfigurationDatabase::eRBXdelay):
                        //datatypestr="DELAY";

                        query  = "SELECT MODULE_POSITION, QIE_CARD_POSITION, QIE_ADC_NUMBER, INTEGER_VALUE ";
                        query += " FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_RBX_DELAY_CONFIG ";
                        query += toolbox::toString(" WHERE TAG_NAME='%s' AND NAME_LABEL='%s'", tag.c_str(), rbx.c_str());

                        break;

                case (ConfigurationDatabase::eRBXgolCurrent):
                        //datatypestr="GOL";

                        query  = "SELECT MODULE_POSITION, QIE_CARD_POSITION, FIBER_NUMBER, INTEGER_VALUE ";
                        query += " FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_RBX_GOL_CONFIG ";
                        query += toolbox::toString(" WHERE TAG_NAME='%s' AND NAME_LABEL='%s'", tag.c_str(), rbx.c_str());

                        break;
                case (ConfigurationDatabase::eRBXledData):
                        //datatypestr="LED";
                        query  = "SELECT LED_AMPLITUDE, SET_LEDS_IS_CHECKED, BUNCH_NUMBER ";
                        query += " FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_RBX_INITPAR_T02_CONFIG ";
                        query += toolbox::toString(" WHERE TAG_NAME='%s' AND NAME_LABEL='%s'", tag.c_str(), rbx.c_str());
                        break;


                case (ConfigurationDatabase::eRBXbroadcast):
                        //datatypestr="";
                        printf("ConfigurationDatabaseImplMySQL::getRBXdata Can't handle BROADCAST yet\n");
                        return;
                case (ConfigurationDatabase::eRBXttcrxPhase):
                        //datatypestr="PHASE";
                        printf("ConfigurationDatabaseImplMySQL::getRBXdata Can't handle TTCRX PHASE yet\n");
                        return;
                case (ConfigurationDatabase::eRBXqieResetDelay):
                        //datatypestr="";
                        printf("ConfigurationDatabaseImplMySQL::getRBXdata Can't handle QIE RESET DELAY yet\n");
                        return;
                case (ConfigurationDatabase::eRBXccaPatterns):
                        XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,"Patterns must use getRBXPatterns, not getRBXData");
                        return;
                default:
                      printf("ConfigurationDatabaseImplMySQL::getRBXdata Can't handle dtype=%d yet\n",dtype);
                      return;
        }

   try {
        //SELECT
        ResultSet *rs = stmt->executeQuery(query);
        while (rs->next()) {

                if (dtype==ConfigurationDatabase::eRBXledData) {
                        //LED_AMPLITUDE, SET_LEDS_IS_CHECKED, BUNCH_NUMBER
                        unsigned int ampl = rs->getInt(1);
                        unsigned int enable = rs->getInt(2);
                        unsigned int bunch = rs->getInt(3);

                        if (enable) enable|=0x1; // global enable if either is on
                        RBXdata.insert(std::pair<ConfigurationDatabase::RBXdatumId,ConfigurationDatabase::RBXdatum>
                                (ConfigurationDatabase::eLEDenable,enable));
                        RBXdata.insert(std::pair<ConfigurationDatabase::RBXdatumId,ConfigurationDatabase::RBXdatum>
                                (ConfigurationDatabase::eLEDamplitude,ampl));
                        RBXdata.insert(std::pair<ConfigurationDatabase::RBXdatumId,ConfigurationDatabase::RBXdatum>
                                (ConfigurationDatabase::eLEDtiming_hb,((bunch&0xFF00)>>8)));
                        RBXdata.insert(std::pair<ConfigurationDatabase::RBXdatumId,ConfigurationDatabase::RBXdatum>
                                (ConfigurationDatabase::eLEDtiming_lb,(bunch&0xFF)));
                } else {
                        //MODULE_POSITION, QIE_CARD_POSITION, QIE_ADC_NUMBER/FIBER_NUMBER, INTEGER_VALUE
                        int rm = rs->getInt(1);
                        int card = rs->getInt(2);
                        int qie_or_gol = rs->getInt(3);
                        unsigned int data = rs->getInt(4);

                        ConfigurationDatabase::RBXdatumId id(rm,card,qie_or_gol,dtype);
                        RBXdata.insert(std::pair<ConfigurationDatabase::RBXdatumId,ConfigurationDatabase::RBXdatum>(id,(unsigned char)(data)));
                }
        }

        //Always terminate statement
        conn_->terminateStatement(stmt);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }

}

void ConfigurationDatabaseImplOracle::getZSThresholds(const std::string& tag, int crate, int slot,
                std::map<hcal::ConfigurationDatabase::ZSChannelId, int>& thresholds)
                noexcept(false) {

   try {
        //Lets run the SQl Query
        Statement* stmt = conn_->createStatement();
        //SELECT HTR_FIBER, FIBER_CHANNEL, ZERO_SUPPRESSION, HTR_FPGA
        //FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_ZERO_SUPPRESSION_LHWM
        //WHERE TAG_NAME='Kukartsev test 1' AND CRATE=2 AND HTR_SLOT=2
    //AND LHWM_VERSION='20'

        std::string query = ("SELECT HTR_FIBER, FIBER_CHANNEL, ZERO_SUPPRESSION, HTR_FPGA ");
        query += " FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_ZERO_SUPPRESSION_LHWM ";
        query+=toolbox::toString(" WHERE TAG_NAME='%s' AND CRATE=%d AND HTR_SLOT=%d", tag.c_str(), crate, slot);
        query+=toolbox::toString(" AND LHWM_VERSION='%s'", lhwm_version.c_str());

        //SELECT
        ResultSet *rs = stmt->executeQuery(query);

        thresholds.clear();

        while (rs->next()) {
                unsigned int fiber = rs->getInt(1);
                unsigned int fc = rs->getInt(2);
                unsigned int zs = rs->getInt(3);
                std::string fpga = getOraString(rs,4);
                int tb;
                if (fpga=="top") tb = 1;
                else tb = 0;
                std::cout << "crate,slot,tb,fiber,fc:" << crate<<slot<<tb<<fiber<<fc<<std::endl;
                hcal::ConfigurationDatabase::ZSChannelId id(crate,slot,(hcal::ConfigurationDatabase::FPGASelection)tb,fiber,fc);
                thresholds[id] = zs;
        }
        //Always terminate statement
        conn_->terminateStatement(stmt);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }

}


void ConfigurationDatabaseImplOracle::getHLXMasks(const std::string& tag, int crate, int slot,
                        std::map<hcal::ConfigurationDatabase::FPGAId, hcal::ConfigurationDatabase::HLXMasks>& masks)
                                        noexcept(false) {
  if (m_hlxMaskCache.crate!=crate || m_hlxMaskCache.tag!=tag) {
    m_hlxMaskCache.clear();
    getHLXMasks_real(tag,crate,m_hlxMaskCache.masks);
    m_hlxMaskCache.crate=crate;
    m_hlxMaskCache.tag=tag;
  }

  masks.clear();
  std::map<ConfigurationDatabase::FPGAId, ConfigurationDatabase::HLXMasks>::const_iterator i;
  for (i=m_hlxMaskCache.masks.begin(); i!=m_hlxMaskCache.masks.end(); i++) {
    if (i->first.slot==slot)
      masks.insert(*i);
  }
}


void ConfigurationDatabaseImplOracle::getHLXMasks_real(const std::string& tag, int crate,
                std::map<ConfigurationDatabase::FPGAId, ConfigurationDatabase::HLXMasks>& masks)
                noexcept(false) {
   try {
        //Lets run the SQl Query
        Statement* stmt = conn_->createStatement();
        std::string query = ("SELECT SLOT_NUMBER, FPGA, OCC_MASK, LHC_MASK, SUM_ET_MASK ");
        query += " FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_HLX_MASKS ";
        query += toolbox::toString(" WHERE TAG_NAME='%s' AND CRATE_NUMBER=%d ", tag.c_str(), crate);

        //SELECT
        ResultSet *rs = stmt->executeQuery(query);
        masks.clear();
        while (rs->next()) {
                int islot = rs->getInt(1);
                std::string fpga = getOraString(rs,2);

                int ifpga;
                if (fpga=="top") ifpga = 1;
                else ifpga = 0;

                hcal::ConfigurationDatabase::FPGAId fpga_id;
                fpga_id=hcal::ConfigurationDatabase::FPGAId(crate, islot,
                                (hcal::ConfigurationDatabase::FPGASelectionEnum)ifpga);
                hcal::ConfigurationDatabase::HLXMasks hlxMask;
                hlxMask.occMask = rs->getInt(3);
                hlxMask.lhcMask = rs->getInt(4);
                hlxMask.sumEtMask = rs->getInt(5);

                masks[fpga_id]=hlxMask;
        }
        //Always terminate statement
        conn_->terminateStatement(stmt);
   } catch (SQLException& e) {
           XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",getOraMessage(&e)));
   }
}

// added by Gena Kukartsev
oracle::occi::Connection * ConfigurationDatabaseImplOracle::getConnection( void ){
  return conn_;
}

oracle::occi::Environment * ConfigurationDatabaseImplOracle::getEnvironment( void ){
  return env_;
}