#include <CondDBESSource.h>

Inheritance diagram for CondDBESSource:

Classes
struct	Stats

Public Types
using	DataKey = edm::eventsetup::DataKey

using	EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey

typedef std::multimap< std::string, ProxyP >	ProxyMap

typedef std::shared_ptr< cond::DataProxyWrapperBase >	ProxyP

enum	RefreshPolicy { NOREFRESH, REFRESH_ALWAYS, REFRESH_OPEN_IOVS, REFRESH_EACH_RUN, RECONNECT_EACH_RUN }

Public Member Functions
	CondDBESSource (const edm::ParameterSet &)

	~CondDBESSource () override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

virtual void	updateLookup (ESRecordsToProxyIndices const &)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const

const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete

std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const

const EventSetupRecordIntervalFinder &	operator= (const EventSetupRecordIntervalFinder &)=delete

void	resetInterval (const eventsetup::EventSetupRecordKey &)

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

Protected Member Functions
void	initConcurrentIOVs (const EventSetupRecordKey &key, unsigned int nConcurrentIOVs) override

bool	isConcurrentFinder () const override

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

void	setIntervalFor (const EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Private Types
typedef std::map< std::string, cond::GTEntry_t >	TagCollection

Private Member Functions
void	fillList (const std::string &pfn, std::vector< std::string > &pfnList, const unsigned int listSize, const std::string &type)

void	fillTagCollectionFromDB (const std::vector< std::string > &connectionStringList, const std::vector< std::string > &prefixList, const std::vector< std::string > &postfixList, const std::vector< std::string > &roottagList, std::map< std::string, cond::GTEntry_t > &replacement, cond::GTMetadata_t &gtMetadata)

void	fillTagCollectionFromGT (const std::string &connectionString, const std::string &prefix, const std::string &postfix, const std::string &roottag, std::set< cond::GTEntry_t > &tagcoll, cond::GTMetadata_t &gtMetadata)

Private Attributes
cond::persistency::ConnectionPool	m_connection

std::string	m_connectionString

bool	m_doDump

std::string	m_frontierKey

unsigned int	m_lastLumi

std::map< std::string, cond::Time_t >	m_lastRecordRuns

unsigned int	m_lastRun

std::mutex	m_mutex

RefreshPolicy	m_policy

ProxyMap	m_proxies

edm::SerialTaskQueue	m_queue

std::map< std::string, cond::Time_t >	m_refreshTimeForRecord

std::map< std::string, std::pair< cond::persistency::Session, std::string > >	m_sessionPool

std::map< std::string, std::pair< cond::persistency::Session, std::string > >	m_sessionPoolForLumiConditions

Stats	m_stats

TagCollection	m_tagCollection

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>

Detailed Description

Definition at line 87 of file CondDBESSource.h.

Member Typedef Documentation

◆ DataKey

using CondDBESSource::DataKey = edm::eventsetup::DataKey

Definition at line 89 of file CondDBESSource.h.

◆ EventSetupRecordKey

using CondDBESSource::EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey

Definition at line 90 of file CondDBESSource.h.

◆ ProxyMap

typedef std::multimap<std::string, ProxyP> CondDBESSource::ProxyMap

Definition at line 92 of file CondDBESSource.h.

◆ ProxyP

typedef std::shared_ptr<cond::DataProxyWrapperBase> CondDBESSource::ProxyP

Definition at line 91 of file CondDBESSource.h.

◆ TagCollection

typedef std::map<std::string, cond::GTEntry_t> CondDBESSource::TagCollection

private

Definition at line 118 of file CondDBESSource.h.

Member Enumeration Documentation

◆ RefreshPolicy

enum CondDBESSource::RefreshPolicy

Enumerator
NOREFRESH
REFRESH_ALWAYS
REFRESH_OPEN_IOVS
REFRESH_EACH_RUN
RECONNECT_EACH_RUN

Definition at line 94 of file CondDBESSource.h.

94 { NOREFRESH, REFRESH_ALWAYS, REFRESH_OPEN_IOVS, REFRESH_EACH_RUN, RECONNECT_EACH_RUN } RefreshPolicy;

Constructor & Destructor Documentation

◆ CondDBESSource()

CondDBESSource::CondDBESSource ( const edm::ParameterSet & iConfig )

explicit

required by eventsetup

Definition at line 98 of file CondDBESSource.cc.

     : m_connection(),
       m_connectionString(""),
       m_frontierKey(""),
       m_lastRun(0),   // for the stat
       m_lastLumi(0),  // for the stat
       m_policy(NOREFRESH),
       m_doDump(iConfig.getUntrackedParameter<bool>("DumpStat", false)) {
   if (iConfig.getUntrackedParameter<bool>("RefreshAlways", false)) {
     m_policy = REFRESH_ALWAYS;
   }
   if (iConfig.getUntrackedParameter<bool>("RefreshOpenIOVs", false)) {
     m_policy = REFRESH_OPEN_IOVS;
   }
   if (iConfig.getUntrackedParameter<bool>("RefreshEachRun", false)) {
     m_policy = REFRESH_EACH_RUN;
   }
   if (iConfig.getUntrackedParameter<bool>("ReconnectEachRun", false)) {
     m_policy = RECONNECT_EACH_RUN;
   }
  
   Stats s = {0, 0, 0, 0, 0, 0, 0, 0};
   m_stats = s;
  
   /*parameter set parsing
    */
   std::string globaltag("");
   if (iConfig.exists("globaltag")) {
     globaltag = iConfig.getParameter<std::string>("globaltag");
     // the global tag _requires_ a connection string
     m_connectionString = iConfig.getParameter<std::string>("connect");
  
     if (!globaltag.empty()) {
       edm::Service<edm::SiteLocalConfig> siteLocalConfig;
       if (siteLocalConfig.isAvailable()) {
         if (siteLocalConfig->useLocalConnectString()) {
           std::string const& localConnectPrefix = siteLocalConfig->localConnectPrefix();
           std::string const& localConnectSuffix = siteLocalConfig->localConnectSuffix();
           m_connectionString = localConnectPrefix + globaltag + localConnectSuffix;
         }
       }
     }
   } else if (iConfig.exists("connect"))  // default connection string
     m_connectionString = iConfig.getParameter<std::string>("connect");
  
   // frontier key
   if (iConfig.exists("frontierKey")) {
     m_frontierKey = iConfig.getParameter<std::string>("frontierKey");
   }
  
   // snapshot
   boost::posix_time::ptime snapshotTime;
   if (iConfig.exists("snapshotTime")) {
     std::string snapshotTimeString = iConfig.getParameter<std::string>("snapshotTime");
     if (!snapshotTimeString.empty())
       snapshotTime = boost::posix_time::time_from_string(snapshotTimeString);
   }
  
   // connection configuration
   if (iConfig.exists("DBParameters")) {
     edm::ParameterSet connectionPset = iConfig.getParameter<edm::ParameterSet>("DBParameters");
     m_connection.setParameters(connectionPset);
   }
   m_connection.configure();
  
   // load specific record/tag info - it will overwrite the global tag ( if any )
   std::map<std::string, cond::GTEntry_t> replacements;
   std::map<std::string, boost::posix_time::ptime> specialSnapshots;
   if (iConfig.exists("toGet")) {
     typedef std::vector<edm::ParameterSet> Parameters;
     Parameters toGet = iConfig.getParameter<Parameters>("toGet");
     for (Parameters::iterator itToGet = toGet.begin(); itToGet != toGet.end(); ++itToGet) {
       std::string recordname = itToGet->getParameter<std::string>("record");
       if (recordname.empty())
         throw cond::Exception("ESSource: The record name has not been provided in a \"toGet\" entry.");
       std::string labelname = itToGet->getUntrackedParameter<std::string>("label", "");
       std::string pfn("");
       if (m_connectionString.empty() || itToGet->exists("connect"))
         pfn = itToGet->getParameter<std::string>("connect");
       std::string tag("");
       std::string fqTag("");
       if (itToGet->exists("tag")) {
         tag = itToGet->getParameter<std::string>("tag");
         fqTag = cond::persistency::fullyQualifiedTag(tag, pfn);
       }
       boost::posix_time::ptime tagSnapshotTime =
           boost::posix_time::time_from_string(std::string(cond::time::MAX_TIMESTAMP));
       if (itToGet->exists("snapshotTime"))
         tagSnapshotTime = boost::posix_time::time_from_string(itToGet->getParameter<std::string>("snapshotTime"));
       if (itToGet->exists("refreshTime")) {
         cond::Time_t refreshTime = itToGet->getParameter<unsigned long long>("refreshTime");
         m_refreshTimeForRecord.insert(std::make_pair(recordname, refreshTime));
       }
  
       std::string recordLabelKey = joinRecordAndLabel(recordname, labelname);
       replacements.insert(
           std::make_pair(recordLabelKey, cond::GTEntry_t(std::make_tuple(recordname, labelname, fqTag))));
       specialSnapshots.insert(std::make_pair(recordLabelKey, tagSnapshotTime));
     }
   }
  
   // get the global tag, merge with "replacement" store in "tagCollection"
   std::vector<std::string> globaltagList;
   std::vector<std::string> connectList;
   std::vector<std::string> pfnPrefixList;
   std::vector<std::string> pfnPostfixList;
   if (!globaltag.empty()) {
     std::string pfnPrefix(iConfig.getUntrackedParameter<std::string>("pfnPrefix", ""));
     std::string pfnPostfix(iConfig.getUntrackedParameter<std::string>("pfnPostfix", ""));
     boost::split(globaltagList, globaltag, boost::is_any_of("|"), boost::token_compress_off);
     fillList(m_connectionString, connectList, globaltagList.size(), "connection");
     fillList(pfnPrefix, pfnPrefixList, globaltagList.size(), "pfnPrefix");
     fillList(pfnPostfix, pfnPostfixList, globaltagList.size(), "pfnPostfix");
   }
  
   cond::GTMetadata_t gtMetadata;
   fillTagCollectionFromDB(connectList, pfnPrefixList, pfnPostfixList, globaltagList, replacements, gtMetadata);
   // if no job specific setting has been found, use the GT timestamp
   if (snapshotTime.is_not_a_date_time())
     snapshotTime = gtMetadata.snapshotTime;
  
   TagCollection::iterator it;
   TagCollection::iterator itBeg = m_tagCollection.begin();
   TagCollection::iterator itEnd = m_tagCollection.end();
  
   std::map<std::string, cond::persistency::Session> sessions;
  
   /* load DataProxy Plugin (it is strongly typed due to EventSetup ideosyncrasis)
    * construct proxy
    * contrary to EventSetup the "object-name" is not used as identifier: multiple entries in a record are
    * dinstinguished only by their label...
    * done in two step: first create ProxyWrapper loading ALL required dictionaries
    * this will allow to initialize POOL in one go for each "database"
    * The real initialization of the Data-Proxies is done in the second loop 
    */
   std::vector<std::unique_ptr<cond::DataProxyWrapperBase>> proxyWrappers(m_tagCollection.size());
   size_t ipb = 0;
   for (it = itBeg; it != itEnd; ++it) {
     proxyWrappers[ipb++] = std::unique_ptr<cond::DataProxyWrapperBase>{
         cond::ProxyFactory::get()->create(buildName(it->second.recordName()))};
   }
  
   // now all required libraries have been loaded
   // init sessions and DataProxies
   ipb = 0;
   for (it = itBeg; it != itEnd; ++it) {
     std::string connStr = m_connectionString;
     std::string tag = it->second.tagName();
     std::pair<std::string, std::string> tagParams = cond::persistency::parseTag(it->second.tagName());
     if (!tagParams.second.empty()) {
       connStr = tagParams.second;
       tag = tagParams.first;
     }
     std::map<std::string, cond::persistency::Session>::iterator p = sessions.find(connStr);
     cond::persistency::Session nsess;
     if (p == sessions.end()) {
       std::string oracleConnStr = cond::persistency::convertoToOracleConnection(connStr);
       std::tuple<std::string, std::string, std::string> connPars =
           cond::persistency::parseConnectionString(oracleConnStr);
       std::string dbService = std::get<1>(connPars);
       std::string dbAccount = std::get<2>(connPars);
       if ((dbService == "cms_orcon_prod" || dbService == "cms_orcon_adg") && dbAccount != "CMS_CONDITIONS")
         edm::LogWarning("CondDBESSource")
             << "[WARNING] You are reading tag \"" << tag << "\" from V1 account \"" << connStr
             << "\". The concerned Conditions might be out of date." << std::endl;
       //open db get tag info (i.e. the IOV token...)
       nsess = m_connection.createReadOnlySession(connStr, "");
       sessions.insert(std::make_pair(connStr, nsess));
     } else
       nsess = (*p).second;
  
     // ownership...
     ProxyP proxy(std::move(proxyWrappers[ipb++]));
     //  instert in the map
     m_proxies.insert(std::make_pair(it->second.recordName(), proxy));
     // initialize
     boost::posix_time::ptime tagSnapshotTime = snapshotTime;
     auto tagSnapshotIter = specialSnapshots.find(it->first);
     if (tagSnapshotIter != specialSnapshots.end())
       tagSnapshotTime = tagSnapshotIter->second;
     // finally, if the snapshot is set to infinity, reset the snapshot to null, to take the full iov set...
     if (tagSnapshotTime == boost::posix_time::time_from_string(std::string(cond::time::MAX_TIMESTAMP)))
       tagSnapshotTime = boost::posix_time::ptime();
  
     proxy->lateInit(nsess, tag, tagSnapshotTime, it->second.recordLabel(), connStr, &m_queue, &m_mutex);
   }
  
   // one loaded expose all other tags to the Proxy!
   CondGetterFromESSource visitor(m_proxies);
   ProxyMap::iterator b = m_proxies.begin();
   ProxyMap::iterator e = m_proxies.end();
   for (; b != e; b++) {
     (*b).second->proxy(0)->loadMore(visitor);
  
     EventSetupRecordKey recordKey(EventSetupRecordKey::TypeTag::findType((*b).first));
     if (recordKey.type() != EventSetupRecordKey::TypeTag()) {
       findingRecordWithKey(recordKey);
       usingRecordWithKey(recordKey);
     }
   }
  
   m_stats.nData = m_proxies.size();
 }

References b, cond::persistency::ConnectionPool::configure(), cond::persistency::convertoToOracleConnection(), cond::persistency::ConnectionPool::createReadOnlySession(), MillePedeFileConverter_cfg::e, edm::ParameterSet::exists(), fillList(), fillTagCollectionFromDB(), edm::EventSetupRecordIntervalFinder::findingRecordWithKey(), edm::eventsetup::heterocontainer::HCTypeTag::findType(), cond::persistency::fullyQualifiedTag(), get, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), download_sqlite_cfg::globaltag, if(), m_connection, m_connectionString, m_frontierKey, m_mutex, m_policy, m_proxies, m_queue, m_refreshTimeForRecord, m_stats, m_tagCollection, cond::time::MAX_TIMESTAMP, eostools::move(), CondDBESSource::Stats::nData, AlCaHLTBitMon_ParallelJobs::p, cond::persistency::parseConnectionString(), cond::persistency::parseTag(), loadRecoTauTagMVAsFromPrepDB_cfi::pfnPostfix, loadRecoTauTagMVAsFromPrepDB_cfi::pfnPrefix, RECONNECT_EACH_RUN, REFRESH_ALWAYS, REFRESH_EACH_RUN, REFRESH_OPEN_IOVS, onlinebeammonitor_dqm_sourceclient-live_cfg::refreshTime, alignCSCRings::s, cond::persistency::ConnectionPool::setParameters(), L1TCSCTPG_cff::siteLocalConfig, loadRecoTauTagMVAsFromPrepDB_cfi::snapshotTime, cond::GTMetadata_t::snapshotTime, submitPVValidationJobs::split(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, DBConfiguration_cff::toGet, edm::eventsetup::EventSetupRecordKey::type(), and edm::eventsetup::DataProxyProvider::usingRecordWithKey().

◆ ~CondDBESSource()

CondDBESSource::~CondDBESSource ( )

override

Definition at line 321 of file CondDBESSource.cc.

                                 {
   //dump info FIXME: find a more suitable place...
   if (m_doDump) {
     std::cout << "CondDBESSource Statistics" << std::endl
               << "DataProxy " << m_stats.nData << " setInterval " << m_stats.nSet << " Runs " << m_stats.nRun
               << " Lumis " << m_stats.nLumi << " Refresh " << m_stats.nRefresh << " Actual Refresh "
               << m_stats.nActualRefresh << " Reconnect " << m_stats.nReconnect << " Actual Reconnect "
               << m_stats.nActualReconnect;
     std::cout << std::endl;
  
     ProxyMap::iterator b = m_proxies.begin();
     ProxyMap::iterator e = m_proxies.end();
     for (; b != e; b++) {
       dumpInfo(std::cout, (*b).first, *(*b).second);
       std::cout << "\n" << std::endl;
     }
  
     // FIXME
     // We shall eventually close transaction and session...
   }
 }

References b, gather_cfg::cout, MillePedeFileConverter_cfg::e, m_doDump, m_proxies, m_stats, CondDBESSource::Stats::nActualReconnect, CondDBESSource::Stats::nActualRefresh, CondDBESSource::Stats::nData, CondDBESSource::Stats::nLumi, CondDBESSource::Stats::nReconnect, CondDBESSource::Stats::nRefresh, CondDBESSource::Stats::nRun, and CondDBESSource::Stats::nSet.

Member Function Documentation

◆ fillList()

void CondDBESSource::fillList	(	const std::string &	pfn,
		std::vector< std::string > &	pfnList,
		const unsigned int	listSize,
		const std::string &	type
	)

private

Definition at line 303 of file CondDBESSource.cc.

                                                      {
   boost::split(listToFill, stringList, boost::is_any_of("|"), boost::token_compress_off);
   // If it is one clone it for each GT
   if (listToFill.size() == 1) {
     for (unsigned int i = 1; i < listSize; ++i) {
       listToFill.push_back(stringList);
     }
   }
   // else if they don't match the number of GTs throw an exception
   else if (listSize != listToFill.size()) {
     throw cond::Exception(
         std::string("ESSource: number of global tag components does not match number of " + type + " strings"));
   }
 }

References mps_fire::i, submitPVValidationJobs::split(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CondDBESSource().

◆ fillTagCollectionFromDB()

void CondDBESSource::fillTagCollectionFromDB	(	const std::vector< std::string > &	connectionStringList,
		const std::vector< std::string > &	prefixList,
		const std::vector< std::string > &	postfixList,
		const std::vector< std::string > &	roottagList,
		std::map< std::string, cond::GTEntry_t > &	replacement,
		cond::GTMetadata_t &	gtMetadata
	)

private

Definition at line 645 of file CondDBESSource.cc.

                                                                            {
   std::set<cond::GTEntry_t> tagcoll;
  
   auto connectionString = connectionStringList.begin();
   auto prefix = prefixList.begin();
   auto postfix = postfixList.begin();
   for (auto roottag = roottagList.begin(); roottag != roottagList.end();
        ++roottag, ++connectionString, ++prefix, ++postfix) {
     fillTagCollectionFromGT(*connectionString, *prefix, *postfix, *roottag, tagcoll, gtMetadata);
   }
  
   std::set<cond::GTEntry_t>::iterator tagCollIter;
   std::set<cond::GTEntry_t>::iterator tagCollBegin = tagcoll.begin();
   std::set<cond::GTEntry_t>::iterator tagCollEnd = tagcoll.end();
  
   // FIXME the logic is a bit perverse: can be surely linearized (at least simplified!) ....
   for (tagCollIter = tagCollBegin; tagCollIter != tagCollEnd; ++tagCollIter) {
     std::string recordLabelKey = joinRecordAndLabel(tagCollIter->recordName(), tagCollIter->recordLabel());
     std::map<std::string, cond::GTEntry_t>::iterator fid = replacement.find(recordLabelKey);
     if (fid != replacement.end()) {
       if (!fid->second.tagName().empty()) {
         cond::GTEntry_t tagMetadata(
             std::make_tuple(tagCollIter->recordName(), tagCollIter->recordLabel(), fid->second.tagName()));
         m_tagCollection.insert(std::make_pair(recordLabelKey, tagMetadata));
         edm::LogInfo("CondDBESSource") << "Replacing tag \"" << tagCollIter->tagName() << "\" for record \""
                                        << tagMetadata.recordName() << "\" and label \"" << tagMetadata.recordLabel()
                                        << "\" with tag " << tagMetadata.tagName()
                                        << "\"; from CondDBESSource::fillTagCollectionFromDB";
       } else {
         m_tagCollection.insert(std::make_pair(recordLabelKey, *tagCollIter));
       }
       replacement.erase(fid);
     } else {
       m_tagCollection.insert(std::make_pair(recordLabelKey, *tagCollIter));
     }
   }
   std::map<std::string, cond::GTEntry_t>::iterator replacementIter;
   std::map<std::string, cond::GTEntry_t>::iterator replacementBegin = replacement.begin();
   std::map<std::string, cond::GTEntry_t>::iterator replacementEnd = replacement.end();
   for (replacementIter = replacementBegin; replacementIter != replacementEnd; ++replacementIter) {
     if (replacementIter->second.tagName().empty()) {
       std::stringstream msg;
       msg << "ESSource: no tag provided for record " << replacementIter->second.recordName();
       if (!replacementIter->second.recordLabel().empty())
         msg << " and label " << replacementIter->second.recordLabel();
       throw cond::Exception(msg.str());
     }
     m_tagCollection.insert(*replacementIter);
   }
 }

References l1RCTOmdsFedVectorProducer_cfi::connectionString, fillTagCollectionFromGT(), m_tagCollection, mps_check::msg, hcallasereventfilter2012_cfi::prefix, cond::GTEntry_t::recordLabel(), cond::GTEntry_t::recordName(), AlCaHLTBitMon_QueryRunRegistry::string, and cond::GTEntry_t::tagName().

Referenced by CondDBESSource().

◆ fillTagCollectionFromGT()

void CondDBESSource::fillTagCollectionFromGT	(	const std::string &	connectionString,
		const std::string &	prefix,
		const std::string &	postfix,
		const std::string &	roottag,
		std::set< cond::GTEntry_t > &	tagcoll,
		cond::GTMetadata_t &	gtMetadata
	)

private

Definition at line 611 of file CondDBESSource.cc.

                                                                            {
   if (!roottag.empty()) {
     if (connectionString.empty())
       throw cond::Exception(std::string("ESSource: requested global tag ") + roottag +
                             std::string(" but not connection string given"));
     std::tuple<std::string, std::string, std::string> connPars =
         cond::persistency::parseConnectionString(connectionString);
     if (std::get<2>(connPars) == "CMS_COND_31X_GLOBALTAG") {
       edm::LogWarning("CondDBESSource")
           << "[WARNING] You are reading Global Tag \"" << roottag
           << "\" from V1 account \"CMS_COND_31X_GLOBALTAG\". The concerned Conditions might be out of date."
           << std::endl;
     } else if (roottag.rfind("::All") != std::string::npos && std::get<2>(connPars) == "CMS_CONDITIONS") {
       edm::LogWarning("CondDBESSource") << "[WARNING] You are trying to read Global Tag \"" << roottag
                                         << "\" - postfix \"::All\" should not be used for V2." << std::endl;
     }
     cond::persistency::Session session = m_connection.createSession(connectionString);
     session.transaction().start(true);
     cond::persistency::GTProxy gtp = session.readGlobalTag(roottag, prefix, postfix);
     gtMetadata.snapshotTime = gtp.snapshotTime();
     for (const auto& gte : gtp) {
       tagcoll.insert(gte);
     }
     session.transaction().commit();
   }
 }

References cond::persistency::Transaction::commit(), l1RCTOmdsFedVectorProducer_cfi::connectionString, cond::persistency::ConnectionPool::createSession(), m_connection, cond::persistency::parseConnectionString(), hcallasereventfilter2012_cfi::prefix, cond::persistency::Session::readGlobalTag(), cond::persistency::GTProxy::snapshotTime(), cond::GTMetadata_t::snapshotTime, cond::persistency::Transaction::start(), AlCaHLTBitMon_QueryRunRegistry::string, and cond::persistency::Session::transaction().

Referenced by fillTagCollectionFromDB().

◆ initConcurrentIOVs()

void CondDBESSource::initConcurrentIOVs	(	const EventSetupRecordKey &	key,
		unsigned int	nConcurrentIOVs
	)

overrideprotectedvirtual

Reimplemented from edm::eventsetup::DataProxyProvider.

Definition at line 599 of file CondDBESSource.cc.

                                                                                                     {
   std::string recordname = key.name();
   ProxyMap::const_iterator b = m_proxies.lower_bound(recordname);
   ProxyMap::const_iterator e = m_proxies.upper_bound(recordname);
   for (ProxyMap::const_iterator p = b; p != e; ++p) {
     if (p->second) {
       p->second->initConcurrentIOVs(nConcurrentIOVs);
     }
   }
 }

References b, MillePedeFileConverter_cfg::e, crabWrapper::key, m_proxies, AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ isConcurrentFinder()

bool CondDBESSource::isConcurrentFinder ( ) const

inlineoverrideprotectedvirtual

Reimplemented from edm::EventSetupRecordIntervalFinder.

Definition at line 106 of file CondDBESSource.h.

106 { return true; }

◆ registerProxies()

edm::eventsetup::DataProxyProvider::KeyedProxiesVector CondDBESSource::registerProxies	(	const EventSetupRecordKey &	iRecordKey,
		unsigned int	iovIndex
	)

overrideprotectedvirtual

Implements edm::eventsetup::DataProxyProvider.

Definition at line 575 of file CondDBESSource.cc.

                                                                   {
   KeyedProxiesVector keyedProxiesVector;
  
   std::string recordname = iRecordKey.name();
  
   ProxyMap::const_iterator b = m_proxies.lower_bound(recordname);
   ProxyMap::const_iterator e = m_proxies.upper_bound(recordname);
   if (b == e) {
     edm::LogInfo("CondDBESSource") << "No DataProxy (Pluging) found for record \"" << recordname
                                    << "\"; from CondDBESSource::registerProxies";
     return keyedProxiesVector;
   }
  
   for (ProxyMap::const_iterator p = b; p != e; ++p) {
     if (nullptr != (*p).second.get()) {
       edm::eventsetup::TypeTag type = (*p).second->type();
       DataKey key(type, edm::eventsetup::IdTags((*p).second->label().c_str()));
       keyedProxiesVector.emplace_back(key, (*p).second->edmProxy(iovIndex));
     }
   }
   return keyedProxiesVector;
 }

References b, MillePedeFileConverter_cfg::e, crabWrapper::key, m_proxies, edm::eventsetup::EventSetupRecordKey::name(), AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ setIntervalFor()

void CondDBESSource::setIntervalFor	(	const EventSetupRecordKey &	iKey,
		const edm::IOVSyncValue &	iTime,
		edm::ValidityInterval &	oInterval
	)

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 347 of file CondDBESSource.cc.

                                                                     {
   std::string recordname = iKey.name();
  
   edm::LogInfo("CondDBESSource") << "Getting data for record \"" << recordname << "\" to be consumed by "
                                  << iTime.eventID() << ", timestamp: " << iTime.time().value()
                                  << "; from CondDBESSource::setIntervalFor";
  
   std::lock_guard<std::mutex> guard(m_mutex);
   m_stats.nSet++;
   //{
   // not really required, keep here for the time being
   if (iTime.eventID().run() != m_lastRun) {
     m_lastRun = iTime.eventID().run();
     m_stats.nRun++;
   }
   if (iTime.luminosityBlockNumber() != m_lastLumi) {
     m_lastLumi = iTime.luminosityBlockNumber();
     m_stats.nLumi++;
   }
   //}
   cond::Time_t lastTime = m_lastRun;
   cond::Time_t defaultIovSize = cond::time::MAX_VAL;
   cond::Time_t minDiffTime = 1;
   bool refreshThisRecord = false;
   if (m_policy != REFRESH_ALWAYS) {
     auto iR = m_refreshTimeForRecord.find(recordname);
     refreshThisRecord = (iR != m_refreshTimeForRecord.end());
     if (refreshThisRecord) {
       lastTime = cond::time::lumiTime(m_lastRun, m_lastLumi);
       defaultIovSize = iR->second;
       minDiffTime = defaultIovSize;
     }
   }
   bool doRefresh = false;
   if (m_policy == REFRESH_EACH_RUN || m_policy == RECONNECT_EACH_RUN || refreshThisRecord) {
     // find out the last run number for the proxy of the specified record
     std::map<std::string, cond::Time_t>::iterator iRec = m_lastRecordRuns.find(recordname);
     if (iRec != m_lastRecordRuns.end()) {
       cond::Time_t lastRecordRun = iRec->second;
       cond::Time_t diffTime = lastTime - lastRecordRun;
       if (lastRecordRun > lastTime)
         diffTime = lastRecordRun - lastTime;
       if (diffTime >= minDiffTime) {
         // a refresh is required!
         doRefresh = true;
         iRec->second = lastTime;
         edm::LogInfo("CondDBESSource") << "Preparing refresh for record \"" << recordname
                                        << "\" since there has been a transition from run/lumi " << lastRecordRun
                                        << " to run/lumi " << lastTime << "; from CondDBESSource::setIntervalFor";
       }
     } else {
       doRefresh = true;
       m_lastRecordRuns.insert(std::make_pair(recordname, lastTime));
       edm::LogInfo("CondDBESSource") << "Preparing refresh for record \"" << recordname << "\" for " << iTime.eventID()
                                      << ", timestamp: " << iTime.time().value()
                                      << "; from CondDBESSource::setIntervalFor";
     }
     if (!doRefresh)
       edm::LogInfo("CondDBESSource") << "Though enabled, refresh not needed for record \"" << recordname << "\" for "
                                      << iTime.eventID() << ", timestamp: " << iTime.time().value()
                                      << "; from CondDBESSource::setIntervalFor";
   } else if (m_policy == REFRESH_ALWAYS || m_policy == REFRESH_OPEN_IOVS) {
     doRefresh = true;
     edm::LogInfo("CondDBESSource") << "Forcing refresh for record \"" << recordname << "\" for " << iTime.eventID()
                                    << ", timestamp: " << iTime.time().value()
                                    << "; from CondDBESSource::setIntervalFor";
   }
  
   oInterval = edm::ValidityInterval::invalidInterval();
  
   // compute the smallest interval (assume all objects have the same timetype....)
   cond::ValidityInterval recordValidity(1, cond::TIMELIMIT);
   cond::TimeType timetype = cond::TimeType::invalid;
   bool userTime = true;
  
   //FIXME use equal_range
   ProxyMap::const_iterator pmBegin = m_proxies.lower_bound(recordname);
   ProxyMap::const_iterator pmEnd = m_proxies.upper_bound(recordname);
   if (pmBegin == pmEnd) {
     edm::LogInfo("CondDBESSource") << "No DataProxy (Pluging) found for record \"" << recordname
                                    << "\"; from CondDBESSource::setIntervalFor";
     return;
   }
  
   for (ProxyMap::const_iterator pmIter = pmBegin; pmIter != pmEnd; ++pmIter) {
     edm::LogInfo("CondDBESSource") << "Processing record \"" << recordname << "\" and label \""
                                    << pmIter->second->label() << "\" for " << iTime.eventID()
                                    << ", timestamp: " << iTime.time().value()
                                    << "; from CondDBESSource::setIntervalFor";
  
     timetype = (*pmIter).second->timeType();
  
     cond::Time_t abtime = cond::time::fromIOVSyncValue(iTime, timetype);
     userTime = (0 == abtime);
  
     if (userTime)
       return;  //  oInterval invalid to avoid that make is called...
  
     if (doRefresh) {
       std::string recKey = joinRecordAndLabel(recordname, pmIter->second->label());
       TagCollection::const_iterator tcIter = m_tagCollection.find(recKey);
       if (tcIter == m_tagCollection.end()) {
         edm::LogInfo("CondDBESSource") << "No Tag found for record \"" << recordname << "\" and label \""
                                        << pmIter->second->label() << "\"; from CondDBESSource::setIntervalFor";
         return;
       }
  
       // first reconnect if required
       if (m_policy == RECONNECT_EACH_RUN || refreshThisRecord) {
         edm::LogInfo("CondDBESSource")
             << "Checking if the session must be closed and re-opened for getting correct conditions"
             << "; from CondDBESSource::setIntervalFor";
         std::stringstream transId;
         transId << lastTime;
         if (!m_frontierKey.empty()) {
           transId << "_" << m_frontierKey;
         }
         std::string connStr = m_connectionString;
         std::pair<std::string, std::string> tagParams = cond::persistency::parseTag(tcIter->second.tagName());
         if (!tagParams.second.empty())
           connStr = tagParams.second;
         std::map<std::string, std::pair<cond::persistency::Session, std::string>>* sessionPool = &m_sessionPool;
         if (refreshThisRecord) {
           sessionPool = &m_sessionPoolForLumiConditions;
         }
         auto iSess = sessionPool->find(connStr);
         bool reopen = false;
         if (iSess != sessionPool->end()) {
           if (iSess->second.second != transId.str()) {
             // the available session is open for a different run: reopen
             reopen = true;
             iSess->second.second = transId.str();
           }
         } else {
           // no available session: probably first run analysed...
           iSess =
               sessionPool->insert(std::make_pair(connStr, std::make_pair(cond::persistency::Session(), transId.str())))
                   .first;
           reopen = true;
         }
         if (reopen) {
           iSess->second.first = m_connection.createReadOnlySession(connStr, transId.str());
           edm::LogInfo("CondDBESSource") << "Re-opening the session with connection string " << connStr
                                          << " and new transaction Id " << transId.str()
                                          << "; from CondDBESSource::setIntervalFor";
         }
  
         edm::LogInfo("CondDBESSource") << "Reconnecting to \"" << connStr << "\" for getting new payload for record \""
                                        << recordname << "\" and label \"" << pmIter->second->label()
                                        << "\" from IOV tag \"" << tcIter->second.tagName() << "\" to be consumed by "
                                        << iTime.eventID() << ", timestamp: " << iTime.time().value()
                                        << "; from CondDBESSource::setIntervalFor";
         pmIter->second->session() = iSess->second.first;
         pmIter->second->reload();
         //if( isSizeIncreased )
         //edm::LogInfo( "CondDBESSource" ) << "After reconnecting, an increased size of the IOV sequence labeled by tag \"" << tcIter->second.tag
         //               << "\" was found; from CondDBESSource::setIntervalFor";
         //m_stats.nActualReconnect += isSizeIncreased;
         m_stats.nReconnect++;
       } else {
         edm::LogInfo("CondDBESSource") << "Refreshing IOV sequence labeled by tag \"" << tcIter->second.tagName()
                                        << "\" for getting new payload for record \"" << recordname << "\" and label \""
                                        << pmIter->second->label() << "\" to be consumed by " << iTime.eventID()
                                        << ", timestamp: " << iTime.time().value()
                                        << "; from CondDBESSource::setIntervalFor";
         pmIter->second->reload();
         //if( isSizeIncreased )
         //  edm::LogInfo( "CondDBESSource" ) << "After refreshing, an increased size of the IOV sequence labeled by tag \"" << tcIter->second.tag
         //                 << "\" was found; from CondDBESSource::setIntervalFor";
         //m_stats.nActualRefresh += isSizeIncreased;
         m_stats.nRefresh++;
       }
     }
  
     /*
       // make oInterval valid For Ever
     {
      oInterval = edm::ValidityInterval(cond::toIOVSyncValue(recordValidity.first,  cond::runnumber, true), 
                                        cond::toIOVSyncValue(recordValidity.second, cond::runnumber, false));
      return;
     }    
     */
  
     //query the IOVSequence
     cond::ValidityInterval validity = (*pmIter).second->setIntervalFor(abtime, defaultIovSize);
  
     edm::LogInfo("CondDBESSource") << "Validity coming from IOV sequence for record \"" << recordname
                                    << "\" and label \"" << pmIter->second->label() << "\": (" << validity.first << ", "
                                    << validity.second << ") for time (type: " << cond::timeTypeNames(timetype) << ") "
                                    << abtime << "; from CondDBESSource::setIntervalFor";
  
     recordValidity.first = std::max(recordValidity.first, validity.first);
     recordValidity.second = std::min(recordValidity.second, validity.second);
   }
  
   if (m_policy == REFRESH_OPEN_IOVS) {
     doRefresh = (recordValidity.second == cond::timeTypeSpecs[timetype].endValue);
     edm::LogInfo("CondDBESSource") << "Validity for record \"" << recordname
                                    << "\" and the corresponding label(s) coming from Condition DB: ("
                                    << recordValidity.first << ", " << recordValidity.first
                                    << ") as the last IOV element in the IOV sequence is infinity"
                                    << "; from CondDBESSource::setIntervalFor";
   }
  
   // to force refresh we set end-value to the minimum such an IOV can extend to: current run or lumiblock
  
   if ((!userTime) && recordValidity.second != 0) {
     edm::IOVSyncValue start = cond::time::toIOVSyncValue(recordValidity.first, timetype, true);
     edm::IOVSyncValue stop = doRefresh ? cond::time::limitedIOVSyncValue(iTime, timetype)
                                        : cond::time::toIOVSyncValue(recordValidity.second, timetype, false);
  
     if (start == edm::IOVSyncValue::invalidIOVSyncValue() && stop != edm::IOVSyncValue::invalidIOVSyncValue()) {
       start = edm::IOVSyncValue::beginOfTime();
     }
     oInterval = edm::ValidityInterval(start, stop);
   }
  
   edm::LogInfo("CondDBESSource") << "Setting validity for record \"" << recordname
                                  << "\" and corresponding label(s): starting at " << oInterval.first().eventID()
                                  << ", timestamp: " << oInterval.first().time().value() << ", ending at "
                                  << oInterval.last().eventID() << ", timestamp: " << oInterval.last().time().value()
                                  << ", for " << iTime.eventID() << ", timestamp: " << iTime.time().value()
                                  << "; from CondDBESSource::setIntervalFor";
 }

References edm::IOVSyncValue::beginOfTime(), cond::persistency::ConnectionPool::createReadOnlySession(), cond::TimeTypeSpecs::endValue, edm::IOVSyncValue::eventID(), edm::ValidityInterval::first(), first, cond::time::fromIOVSyncValue(), if(), edm::ValidityInterval::invalidInterval(), edm::IOVSyncValue::invalidIOVSyncValue(), edm::ValidityInterval::last(), cond::time::limitedIOVSyncValue(), edm::IOVSyncValue::luminosityBlockNumber(), cond::time::lumiTime(), m_connection, m_connectionString, m_frontierKey, m_lastLumi, m_lastRecordRuns, m_lastRun, m_mutex, m_policy, m_proxies, m_refreshTimeForRecord, m_sessionPool, m_sessionPoolForLumiConditions, m_stats, m_tagCollection, genParticles_cff::map, SiStripPI::max, cond::time::MAX_VAL(), min(), edm::eventsetup::EventSetupRecordKey::name(), CondDBESSource::Stats::nLumi, CondDBESSource::Stats::nReconnect, CondDBESSource::Stats::nRefresh, CondDBESSource::Stats::nRun, CondDBESSource::Stats::nSet, cond::persistency::parseTag(), RECONNECT_EACH_RUN, REFRESH_ALWAYS, REFRESH_EACH_RUN, REFRESH_OPEN_IOVS, edm::EventID::run(), AlCaHLTBitMon_QueryRunRegistry::string, edm::IOVSyncValue::time(), cond::TIMELIMIT(), DBConfiguration_cff::timetype, cond::timeTypeNames(), cond::timeTypeSpecs, cond::time::toIOVSyncValue(), and edm::Timestamp::value().

Member Data Documentation

◆ m_connection

cond::persistency::ConnectionPool CondDBESSource::m_connection

private

Definition at line 111 of file CondDBESSource.h.

Referenced by CondDBESSource(), fillTagCollectionFromGT(), and setIntervalFor().

◆ m_connectionString

std::string CondDBESSource::m_connectionString

private

Definition at line 112 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_doDump

bool CondDBESSource::m_doDump

private

Definition at line 146 of file CondDBESSource.h.

Referenced by ~CondDBESSource().

◆ m_frontierKey

std::string CondDBESSource::m_frontierKey

private

Definition at line 113 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_lastLumi

unsigned int CondDBESSource::m_lastLumi

private

Definition at line 143 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_lastRecordRuns

std::map<std::string, cond::Time_t> CondDBESSource::m_lastRecordRuns

private

Definition at line 124 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_lastRun

unsigned int CondDBESSource::m_lastRun

private

Definition at line 142 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_mutex

std::mutex CondDBESSource::m_mutex

private

Definition at line 127 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_policy

RefreshPolicy CondDBESSource::m_policy

private

Definition at line 144 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_proxies

ProxyMap CondDBESSource::m_proxies

private

Definition at line 116 of file CondDBESSource.h.

Referenced by CondDBESSource(), initConcurrentIOVs(), registerProxies(), setIntervalFor(), and ~CondDBESSource().

◆ m_queue

edm::SerialTaskQueue CondDBESSource::m_queue

private

Definition at line 126 of file CondDBESSource.h.

Referenced by CondDBESSource().

◆ m_refreshTimeForRecord

std::map<std::string, cond::Time_t> CondDBESSource::m_refreshTimeForRecord

private

Definition at line 121 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_sessionPool

std::map<std::string, std::pair<cond::persistency::Session, std::string> > CondDBESSource::m_sessionPool

private

Definition at line 122 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_sessionPoolForLumiConditions

std::map<std::string, std::pair<cond::persistency::Session, std::string> > CondDBESSource::m_sessionPoolForLumiConditions

private

Definition at line 123 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_stats

Stats CondDBESSource::m_stats

private

Definition at line 140 of file CondDBESSource.h.

Referenced by CondDBESSource(), setIntervalFor(), and ~CondDBESSource().

◆ m_tagCollection

TagCollection CondDBESSource::m_tagCollection

private

Definition at line 120 of file CondDBESSource.h.

Referenced by CondDBESSource(), fillTagCollectionFromDB(), and setIntervalFor().

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ DataKey

◆ EventSetupRecordKey

◆ ProxyMap

◆ ProxyP

◆ TagCollection

Member Enumeration Documentation

◆ RefreshPolicy

Constructor & Destructor Documentation

◆ CondDBESSource()

◆ ~CondDBESSource()

Member Function Documentation

◆ fillList()

◆ fillTagCollectionFromDB()

◆ fillTagCollectionFromGT()

◆ initConcurrentIOVs()

◆ isConcurrentFinder()

◆ registerProxies()

◆ setIntervalFor()

Member Data Documentation

◆ m_connection

◆ m_connectionString

◆ m_doDump

◆ m_frontierKey

◆ m_lastLumi

◆ m_lastRecordRuns

◆ m_lastRun

◆ m_mutex

◆ m_policy

◆ m_proxies

◆ m_queue

◆ m_refreshTimeForRecord

◆ m_sessionPool

◆ m_sessionPoolForLumiConditions

◆ m_stats

◆ m_tagCollection