TrigConf::TrigDBL1BunchGroupSetLoader Class Reference

Loader of trigger configurations from Json files. More...

#include <TrigDBL1BunchGroupSetLoader.h>

Inheritance diagram for TrigConf::TrigDBL1BunchGroupSetLoader:

Collaboration diagram for TrigConf::TrigDBL1BunchGroupSetLoader:

Public Member Functions
	TrigDBL1BunchGroupSetLoader (const std::string &connection)
	Constructor.
virtual	~TrigDBL1BunchGroupSetLoader () override
	Destructor - cannot be defined here because QueryDefinition is an incomplete type.
bool	loadBunchGroupSet (unsigned int bgsk, L1BunchGroupSet &bgs, const std::string &outFileName="") const
	Load content from the Trigger DB into an L1PrescalesSet for a given L1PrescaleKey (L1PSK).
void	setCrestConnection (const std::string &server, const std::string &version="")
	declare CREST as the source of the configuration An empty crest server makes it use Oracle
void	setCrestTrigDB (const std::string &crestTrigDB)
	set trigger db for the crest connection
size_t	schemaVersion (coral::ISessionProxy *session) const
	access to TriggerDB schema version
void	setLevel (MSGTC::Level lvl)
MSGTC::Level	outputLevel () const
bool	msgLvl (const MSGTC::Level lvl) const
	Test the output level.
MsgStreamTC &	msg () const
	The standard message stream.
MsgStreamTC &	msg (const MSGTC::Level lvl) const
	The standard message stream.
const std::string &	getName () const
	name accessor

Protected Member Functions
bool	useCrest () const
std::string	getTrigDataCrest (const std::string &type, int key) const
	Get trigger configuration from the TriggerDB through Crest.
std::unique_ptr< coral::ISessionProxy >	createDBSession () const
	create (if needed) DB session and return the session proxy
QueryDefinition	getQueryDefinition (size_t schemaVersion, const std::map< size_t, QueryDefinition > &queries) const
	return query for given schemaVersion from possible queries
void	loadFromCrest (unsigned int key, boost::property_tree::ptree &pt, const std::string &outFileName, const std::string &description, const std::string &query_type) const
void	loadFromOracle (unsigned int key, boost::property_tree::ptree &pt, const std::string &outFileName, const std::string &description, const std::map< size_t, QueryDefinition > &queries) const

Private Attributes
std::map< size_t, QueryDefinition >	m_queries
bool	m_useCrest {false}
std::string	m_connection {""}
std::string	m_crestServer {""}
std::string	m_crestVersion {""}
std::string	m_crestTrigDb {""}
int	m_retrialPeriod {0}
int	m_retrialTimeout {0}
int	m_connectionTimeout {0}
boost::thread_specific_ptr< MsgStreamTC >	m_msg_tls
	MsgStreamTC instance (a std::cout like with print-out levels).
std::string	m_name

Detailed Description

Loader of trigger configurations from Json files.

Definition at line 24 of file TrigDBL1BunchGroupSetLoader.h.

Constructor & Destructor Documentation

TrigDBL1BunchGroupSetLoader()

TrigConf::TrigDBL1BunchGroupSetLoader::TrigDBL1BunchGroupSetLoader

(

const std::string &

connection

)

Constructor.

Definition at line 6 of file TrigDBL1BunchGroupSetLoader.cxx.

                                                                                             : 
   TrigDBLoader("TrigDBL1BunchGroupSetLoader", connection)
{
   { // query for all schema versions
      auto & q = m_queries[1];
      // tables
      q.addToTableList ( "L1_BUNCH_GROUP_SET" );
      // bind vars
      q.extendBinding<int>("key");
      // conditions
      q.extendCondition("L1BGS_ID = :key");
      // attributes
      q.extendOutput<coral::Blob>( "L1BGS_DATA" );
      // the field with the data
      q.setDataName("L1BGS_DATA");
   }
}

~TrigDBL1BunchGroupSetLoader()

TrigConf::TrigDBL1BunchGroupSetLoader::~TrigDBL1BunchGroupSetLoader ( )

overridevirtualdefault

Destructor - cannot be defined here because QueryDefinition is an incomplete type.

Member Function Documentation

createDBSession()

std::unique_ptr< coral::ISessionProxy > TrigConf::TrigDBLoader::createDBSession ( ) const

protectedinherited

create (if needed) DB session and return the session proxy

Definition at line 107 of file TrigDBLoader.cxx.

                                            {
 
   coral::ConnectionService connSvc;
   coral::IConnectionServiceConfiguration& csc = connSvc.configuration();
   csc.setConnectionRetrialPeriod( m_retrialPeriod );
   csc.setConnectionRetrialTimeOut( m_retrialTimeout );
   csc.setConnectionTimeOut( m_connectionTimeout );
 
   /* TODO
   if(csc.replicaSortingAlgorithm() == nullptr) { // likely to be standalone, create our own
      TRG_MSG_INFO("Create own ReplicaSortingAlgorithm");
      m_replicaSorter = new TrigConf::ReplicaSorter();
      csc.setReplicaSortingAlgorithm(*m_replicaSorter);
   }
   */
 
   TRG_MSG_INFO("Connecting to " << m_connection);
 
   auto proxy = std::unique_ptr<coral::ISessionProxy>( connSvc.connect(m_connection, coral::AccessMode::ReadOnly) );
 
   TRG_MSG_INFO("Opened session " << m_connection << " with  retrialPeriod/retrialTimeout/connectionTimeout: " 
                << m_retrialPeriod << "/" << m_retrialTimeout << "/" << m_connectionTimeout);
 
   return proxy;
}

getName()

const std::string & TrigConf::TrigConfMessaging::getName ( ) const

inlineinherited

name accessor

Returns

the name

Definition at line 101 of file TrigConfMessaging.h.

                                                           {
    return m_name;
  }

getQueryDefinition()

TrigConf::QueryDefinition TrigConf::TrigDBLoader::getQueryDefinition ( size_t schemaVersion, const std::map< size_t, QueryDefinition > & queries ) const

protectedinherited

return query for given schemaVersion from possible queries

Definition at line 174 of file TrigDBLoader.cxx.

{
   // find the largest version key in the map of defined queries that is <= the schemaVersion
   size_t maxDefVersion = 0;
   for(auto & entry : queries) {
      size_t vkey = entry.first;
      if(vkey>maxDefVersion and vkey<=schemaVersion) {
         maxDefVersion = vkey;
      }
   }
   // if nothing found, throw an error
   if( maxDefVersion==0 ) {
      TRG_MSG_ERROR("No query for schema version " << schemaVersion << " defined" );
      throw TrigConf::NoQueryException(std::format("No query available for schema version {}", schemaVersion));
   }
   return queries.at(maxDefVersion);
}

getTrigDataCrest()

std::string TrigConf::TrigDBLoader::getTrigDataCrest ( const std::string & type, int key ) const

protectedinherited

Get trigger configuration from the TriggerDB through Crest.

Parameters

type	The type of trigger configuration data to access L1PS => L1 prescale (with L1PS key) HLTPS => HLT prescale (with HLTPS key) L1M => L1 menu (with SMK) HLTM => HLT menu (with SMK) JO => Job options (with SMK) BGS => bunch group set (with BGS key) MGS => monitoring group (with SMK)
key	The trigger key

Definition at line 134 of file TrigDBLoader.cxx.

                                                                            {
   /*
   To get the trigger data from the TriggerDB using CrestApi, it has been agreed to 
   use the API's payload query with a special specifier
 
   triggerdb://<TrigDBSpec>/<TypeSpec>/<DBKey>
 
   Possible TrigDBSpec: CONF_DATA_RUN3, CONF_MC_RUN3, CONF_REPR_RUN3
   Possible TypeSpec: L1PS, HLTM, L1M, HLTPS, BGS, MGS, JO
   */
 
   std::string url = m_crestServer + m_crestVersion;
   std::string query = std::format("triggerdb://{}/{}/{}", m_crestTrigDb, type, key);
 
#if 0
   /*
   the final implementation should be the code below
   however, in the version used by 24.0 the function CrestApi.getPayload(hash) does not work
   for the trigger: it includes a hash validation that is not applicable for the trigger
   but only for conditions payload queries by hash
   */ 
   Crest::CrestApi capi = Crest::CrestApi(url);
   std::string payload = capi.getPayload(query);
#else
   /*
   so for release 24.0 and until the access to the trigger payload is implemented in CrestApi
   the CrestRequest is build manually. Luckily all needed functionality is accessible
   (this code is a copy of CrestApi::getPayload() without the checkHash())
   */
   Crest::CrestRequest request = Crest::CrestRequest();
   request.setUrl(url);
   std::string current_path = "payloads/data?format=BLOB&hash=" + query;
   nlohmann::json js = nullptr;
   std::string payload = request.performRequest(current_path, Crest::Action::GET, js, "TrigDbLoader");
#endif
 
   return payload;
}

loadBunchGroupSet()

bool TrigConf::TrigDBL1BunchGroupSetLoader::loadBunchGroupSet	(	unsigned int	bgsk,
		TrigConf::L1BunchGroupSet &	bgs,
		const std::string &	outFileName = "" ) const

Load content from the Trigger DB into an L1PrescalesSet for a given L1PrescaleKey (L1PSK).

Parameters

l1psk	[in] the L1PSK that should be loaded
l1pss	[out] the loaded L1PrescalesSet
outFileName	[in] name of file to write out the loaded data (optional, by default no file will be written)

Returns

true if loading (and optional writing) was successfull

Definition at line 28 of file TrigDBL1BunchGroupSetLoader.cxx.

{
   // load data into ptree
   boost::property_tree::ptree pt;
   if(useCrest()) {
      loadFromCrest(bgsk, pt, outFileName, "L1 bunchgroups", "BGS");
   } else {
      loadFromOracle(bgsk, pt, outFileName, "L1 bunchgroups", m_queries);
   }
    
   // fill L1BunchGroupSet with data
   try {
      bgs.setData(std::move(pt));
      bgs.setBGSK(bgsk);
   }
   catch(std::exception & ex) {
      bgs.clear();
      TRG_MSG_ERROR("When reading L1 bunchgroup set for L1 BGSK " << bgsk << " a parsing error occured ( " << ex.what() <<" )" );
      throw TrigConf::ParsingException("TrigDBL1BunchGroupSetLoader: parsing error " + std::string(ex.what()));
   }
 
   return true;
}

loadFromCrest()

void TrigConf::TrigDBLoader::loadFromCrest ( unsigned int key, boost::property_tree::ptree & pt, const std::string & outFileName, const std::string & description, const std::string & query_type ) const

protectedinherited

Definition at line 194 of file TrigDBLoader.cxx.

{
   std::string payload;
   try {
      payload = getTrigDataCrest(query_type, key);
   }
   catch(Crest::CrestException & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " from crest a CrestException was caught ( " << ex.what() <<" )" );
      throw TrigConf::CrestLoadingException(std::format("{}: {}", getName(), ex.what()));
   }
   if(!outFileName.empty()) {
      writeRawFile(payload, outFileName);
      TRG_MSG_INFO("Wrote file " << outFileName);
   }
   try {
      stringToPtree(payload, pt);
   }
   catch(boost::property_tree::json_parser_error & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " from crest a ptree json parser error was caught ( " << ex.what() <<" )" );
      throw TrigConf::JsonParsingException(std::format("{}: {}", getName(), ex.what()));
   }
}

loadFromOracle()

void TrigConf::TrigDBLoader::loadFromOracle ( unsigned int key, boost::property_tree::ptree & pt, const std::string & outFileName, const std::string & description, const std::map< size_t, QueryDefinition > & queries ) const

protectedinherited

Definition at line 220 of file TrigDBLoader.cxx.

{
   auto session = createDBSession();
   session->transaction().start( /*bool readonly=*/ true);
   const size_t sv = schemaVersion(session.get());
   QueryDefinition qdef = getQueryDefinition(sv, queries);
   try {
      qdef.setBoundValue<int>("key", key);
      auto q = qdef.createQuery( session.get() );
      auto & cursor = q->execute();
      if ( ! cursor.next() ) {
         TRG_MSG_ERROR("Tried reading " << description << ", but key " << key << " is not available" );
         throw TrigConf::NoKeyException(std::format("{}: key {} not available", getName(), key));
      }
      const coral::AttributeList& row = cursor.currentRow();
      const coral::Blob& dataBlob = row[qdef.dataName()].data<coral::Blob>();
 
      if(!outFileName.empty()) {
         writeRawFile( dataBlob, outFileName );
         TRG_MSG_INFO("Wrote file " << outFileName);
      }
      blobToPtree( dataBlob, pt );
   }
   catch(coral::QueryException & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " a coral::QueryException was caught ( " << ex.what() <<" )" );
      throw TrigConf::QueryException(std::format("{}: {}", getName(), ex.what()));
   }
   catch(boost::property_tree::json_parser_error & ex) {
      TRG_MSG_ERROR("When reading " << description << " for key " << key << " a ptree json parser error was caught ( " << ex.what() <<" )" );
      throw TrigConf::JsonParsingException(std::format("{}: {}", getName(), ex.what()));
   }
}

msg() [1/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 86 of file TrigConfMessaging.h.

  {
    MsgStreamTC* ms = m_msg_tls.get();
    if (!ms) {
      ms = new MsgStreamTC(m_name);
      m_msg_tls.reset(ms);
    }
    return *ms;
  }

msg() [2/2]

MsgStreamTC & TrigConf::TrigConfMessaging::msg ( const MSGTC::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 96 of file TrigConfMessaging.h.

  {
    return msg() << lvl;
  }

msgLvl()

bool TrigConf::TrigConfMessaging::msgLvl ( const MSGTC::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 75 of file TrigConfMessaging.h.

  {
    if (msg().level() <= lvl) {
      msg() << lvl;
      return true;
    }
    else {
      return false;
    }
  }

outputLevel()

MSGTC::Level TrigConf::TrigDBLoader::outputLevel ( ) const

inlineinherited

Definition at line 70 of file TrigDBLoader.h.

{ return msg().level(); }

schemaVersion()

size_t TrigConf::TrigDBLoader::schemaVersion ( coral::ISessionProxy * session ) const

inherited

access to TriggerDB schema version

Returns

version of the DB schema (0 - no version, >0 - schema version)

Definition at line 38 of file TrigDBLoader.cxx.

                                                                     {
 
   static const std::string versionTagPrefix("Trigger-Run3-Schema-v");
 
   // if database has no schema version, then we return 0
   if(! session->nominalSchema().existsTable("TRIGGER_SCHEMA") ) {
      throw std::runtime_error( "Trigger schema has no schema version table" );
   }
   
   TrigConf::QueryDefinition qdef;
   // tables
   qdef.addToTableList ( "TRIGGER_SCHEMA" );
   // attributes
   qdef.extendOutput<std::string>( "TS_TAG" );
 
   auto query = qdef.createQuery( session );
   auto & cursor = query->execute();
   if ( ! cursor.next() ) {
      throw std::runtime_error( "Trigger schema has schema version table but it is empty" );
   }
 
   const coral::AttributeList& row = cursor.currentRow();
   std::string versionTag = row["TS_TAG"].data<std::string>();
   if( ! versionTag.starts_with(versionTagPrefix)) {
      throw std::runtime_error(std::format("Tag format error: Trigger schema version tag {} does not start with {}", versionTag, versionTagPrefix));      
   }
   
   std::string vstr = versionTag.substr(versionTagPrefix.size()); // the part of the string containing the version
   size_t schemaVersion{0};
   try {
      schemaVersion = std::stoi(vstr);
   }
   catch (const std::invalid_argument& ia) {
      TRG_MSG_ERROR("Invalid argument when interpreting the version part " << vstr << " of schema tag " << versionTag << ". " << ia.what());
      throw;
   }
 
   TRG_MSG_INFO("TriggerDB schema version: " << schemaVersion);
   return schemaVersion;
}

setCrestConnection()

void TrigConf::TrigDBLoader::setCrestConnection ( const std::string & server, const std::string & version = "" )

inherited

declare CREST as the source of the configuration An empty crest server makes it use Oracle

Parameters

server	The crest server. An empty string disables Crest and enables Oracle (the default)
version	The version of the crest api. Usually not needed. If not given, it defaults to the default API version (see CrestApi/CrestApiBase.h)

Definition at line 80 of file TrigDBLoader.cxx.

                                                                                            {
   // server
   m_crestServer = server;
   if(m_crestServer.ends_with('/')) { // remove trailing '/'
      m_crestServer.pop_back();
   }
 
   // use crest flag
   m_useCrest = ! m_crestServer.empty();
 
   // version
   if(version.empty()) {
      m_crestVersion = DEFAULT_CREST_API_VERSION; // defined in CrestApi/CrestApiBase.h
   } else {
      m_crestVersion = version;
   }
   if(!m_crestVersion.starts_with('/')) { // prepend '/' if not existent
      m_crestVersion = "/" + m_crestVersion;
   }
}

setCrestTrigDB()

void TrigConf::TrigDBLoader::setCrestTrigDB ( const std::string & crestTrigDB )

inherited

set trigger db for the crest connection

Parameters

crestTrigDB

the source trigger DB. Possible values currently CONF_DATA_RUN3 => ATLAS_CONF_TRIGGER_RUN3 CONF_MC_RUN3 => ATLAS_CONF_TRIGGER_MC_RUN3 CONF_REPR_RUN3 => ATLAS_CONF_TRIGGER_REPR_RUN3

Definition at line 102 of file TrigDBLoader.cxx.

                                                                  {
   m_crestTrigDb = crestTrigDB;
}

setLevel()

void TrigConf::TrigDBLoader::setLevel ( MSGTC::Level lvl )

inlineinherited

Definition at line 68 of file TrigDBLoader.h.

{ msg().setLevel(lvl); }

useCrest()

bool TrigConf::TrigDBLoader::useCrest ( ) const

inlineprotectedinherited

Definition at line 74 of file TrigDBLoader.h.

                            {
         return m_useCrest;
      }

Member Data Documentation

m_connection

std::string TrigConf::TrigDBLoader::m_connection {""}

privateinherited

Definition at line 110 of file TrigDBLoader.h.

{""};

m_connectionTimeout

int TrigConf::TrigDBLoader::m_connectionTimeout {0}

privateinherited

Definition at line 116 of file TrigDBLoader.h.

{0};

m_crestServer

std::string TrigConf::TrigDBLoader::m_crestServer {""}

privateinherited

Definition at line 111 of file TrigDBLoader.h.

{""};

m_crestTrigDb

std::string TrigConf::TrigDBLoader::m_crestTrigDb {""}

privateinherited

Definition at line 113 of file TrigDBLoader.h.

{""};

m_crestVersion

std::string TrigConf::TrigDBLoader::m_crestVersion {""}

privateinherited

Definition at line 112 of file TrigDBLoader.h.

{""};

m_msg_tls

boost::thread_specific_ptr<MsgStreamTC> TrigConf::TrigConfMessaging::m_msg_tls

mutableprivateinherited

MsgStreamTC instance (a std::cout like with print-out levels).

Definition at line 71 of file TrigConfMessaging.h.

m_name

std::string TrigConf::TrigConfMessaging::m_name

privateinherited

Definition at line 72 of file TrigConfMessaging.h.

m_queries

std::map<size_t, QueryDefinition> TrigConf::TrigDBL1BunchGroupSetLoader::m_queries

private

Definition at line 45 of file TrigDBL1BunchGroupSetLoader.h.

m_retrialPeriod

int TrigConf::TrigDBLoader::m_retrialPeriod {0}

privateinherited

Definition at line 114 of file TrigDBLoader.h.

{0};

m_retrialTimeout

int TrigConf::TrigDBLoader::m_retrialTimeout {0}

privateinherited

Definition at line 115 of file TrigDBLoader.h.

{0};

m_useCrest

bool TrigConf::TrigDBLoader::m_useCrest {false}

privateinherited

Definition at line 109 of file TrigDBLoader.h.

{false};

---

The documentation for this class was generated from the following files:

• TrigDBL1BunchGroupSetLoader.h
• TrigDBL1BunchGroupSetLoader.cxx