#include <CondDBESSource.h>

Inheritance diagram for CondDBESSource:

Classes
struct	Stats

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

using	EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey

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

typedef std::multimap< std::string, ResolverP >	ResolverMap

typedef std::shared_ptr< cond::ProductResolverWrapperBase >	ResolverP

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

	~CondDBESSource () override

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

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

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

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

virtual void	updateLookup (ESRecordsToProductResolverIndices const &)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () 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)

Public Attributes
std::string	m_jsonDumpFilename

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

bool	isConcurrentFinder () const override

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

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

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
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)

void	printStatistics (const Stats &stats) const

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, unsigned int >	m_lastRecordRuns

unsigned int	m_lastRun

std::mutex	m_mutex

RefreshPolicy	m_policy

edm::SerialTaskQueue	m_queue

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

ResolverMap	m_resolvers

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::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

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.

◆ ResolverMap

typedef std::multimap<std::string, ResolverP> CondDBESSource::ResolverMap

Definition at line 92 of file CondDBESSource.h.

◆ ResolverP

typedef std::shared_ptr<cond::ProductResolverWrapperBase> CondDBESSource::ResolverP

Definition at line 91 of file CondDBESSource.h.

◆ TagCollection

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

private

Definition at line 120 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;

CondDBESSource::RECONNECT_EACH_RUN

Definition: CondDBESSource.h:94

CondDBESSource::REFRESH_EACH_RUN

Definition: CondDBESSource.h:94

CondDBESSource::REFRESH_ALWAYS

Definition: CondDBESSource.h:94

CondDBESSource::NOREFRESH

Definition: CondDBESSource.h:94

CondDBESSource::REFRESH_OPEN_IOVS

Definition: CondDBESSource.h:94

CondDBESSource::RefreshPolicy

RefreshPolicy

Definition: CondDBESSource.h:94

Constructor & Destructor Documentation

◆ CondDBESSource()

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

explicit

required by eventsetup

Definition at line 123 of file CondDBESSource.cc.

References b, cond::persistency::ConnectionPool::configure(), cond::persistency::convertoToOracleConnection(), cond::persistency::ConnectionPool::createReadOnlySession(), MillePedeFileConverter_cfg::e, edm::ParameterSet::exists(), fillList(), fillTagCollectionFromDB(), edm::EventSetupRecordIntervalFinder::findingRecordWithKey(), cond::persistency::fullyQualifiedTag(), get, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), download_sqlite_cfg::globaltag, ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, m_connection, m_connectionString, m_frontierKey, m_mutex, m_policy, m_queue, m_refreshTimeForRecord, m_resolvers, 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, beamspotdip_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, makeGlobalPositionRcd_cfg::tag, GlobalPosition_Frontier_DevDB_cff::toGet, edm::eventsetup::EventSetupRecordKey::type(), and edm::eventsetup::ESProductResolverProvider::usingRecordWithKey().

     : m_jsonDumpFilename(iConfig.getUntrackedParameter<std::string>("JsonDumpFileName", "")),
       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
   m_frontierKey = iConfig.getUntrackedParameter<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, std::make_pair(refreshTime, true)));
       }
 
       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 ProductResolver 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 ResolverWrapper loading ALL required dictionaries
    * this will allow to initialize POOL in one go for each "database"
    * The real initialization of the Data-Resolvers is done in the second loop 
    */
   std::vector<std::unique_ptr<cond::ProductResolverWrapperBase>> resolverWrappers(m_tagCollection.size());
   size_t ipb = 0;
   for (it = itBeg; it != itEnd; ++it) {
     size_t ind = ipb++;
     resolverWrappers[ind] = std::unique_ptr<cond::ProductResolverWrapperBase>{
         cond::ProductResolverFactory::get()->tryToCreate(buildName(it->second.recordName()))};
     if (!resolverWrappers[ind].get()) {
       edm::LogWarning("CondDBESSource") << "Plugin for Record " << it->second.recordName() << " has not been found.";
     }
   }
 
   // now all required libraries have been loaded
   // init sessions and DataResolvers
   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...
     ResolverP resolver(std::move(resolverWrappers[ipb++]));
     //  instert in the map
     if (resolver.get()) {
       m_resolvers.insert(std::make_pair(it->second.recordName(), resolver));
       // 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();
 
       resolver->lateInit(nsess, tag, tagSnapshotTime, it->second.recordLabel(), connStr, &m_queue, &m_mutex);
     }
   }
 
   // one loaded expose all other tags to the Proxy!
   CondGetterFromESSource visitor(m_resolvers);
   ResolverMap::iterator b = m_resolvers.begin();
   ResolverMap::iterator e = m_resolvers.end();
   for (; b != e; b++) {
     (*b).second->proxy(0)->loadMore(visitor);
 
     EventSetupRecordKey recordKey = b->second->recordKey();
     if (recordKey.type() != EventSetupRecordKey::TypeTag()) {
       findingRecordWithKey(recordKey);
       usingRecordWithKey(recordKey);
     } else {
       edm::LogWarning("CondDBESSource") << "Failed to load key for record " << b->first
                                         << ". No data from this record will be available.";
     }
   }
 
   m_stats.nData = m_resolvers.size();
 }

◆ ~CondDBESSource()

CondDBESSource::~CondDBESSource ( )

override

Definition at line 371 of file CondDBESSource.cc.

References b, gather_cfg::cout, getInfo::dumpInfo(), MillePedeFileConverter_cfg::e, mps_splice::entry, m_doDump, m_jsonDumpFilename, m_resolvers, m_stats, printStatistics(), saveJsonToFile(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                 {
   //dump info FIXME: find a more suitable place...
   if (m_doDump) {
     //Output CondDBESSource Statistics to the console
     printStatistics(m_stats);
 
     ResolverMap::iterator b = m_resolvers.begin();
     ResolverMap::iterator e = m_resolvers.end();
     for (; b != e; b++) {
       dumpInfo(std::cout, (*b).first, *(*b).second);
       std::cout << "\n" << std::endl;
     }
   }
   //if filename was provided for iConfig by process.GlobalTag.JsonDumpFileName =cms.untracked.string("CondDBESSource.json")
   if (!m_jsonDumpFilename.empty()) {
     json jsonData;
 
     for (const auto& entry : m_resolvers) {
       std::string recName = entry.first;
       const auto& proxy = *entry.second;
       dumpInfoJson(jsonData, recName, proxy);
     }
     //Save the dump data to a file in JSON format
     saveJsonToFile(jsonData, m_jsonDumpFilename);
   }
   // FIXME
   // We shall eventually close transaction and session...
 }

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 336 of file CondDBESSource.cc.

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

Referenced by CondDBESSource().

                                                      {
   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"));
   }
 }

◆ 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 688 of file CondDBESSource.cc.

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

Referenced by CondDBESSource().

                                                                            {
   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);
   }
 }

◆ 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 654 of file CondDBESSource.cc.

References cond::persistency::Transaction::commit(), l1RCTOmdsFedVectorProducer_cfi::connectionString, cond::persistency::ConnectionPool::createSession(), m_connection, cond::persistency::parseConnectionString(), nano_postproc::postfix, 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().

                                                                            {
   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();
   }
 }

◆ initConcurrentIOVs()

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

overrideprotectedvirtual

Reimplemented from edm::eventsetup::ESProductResolverProvider.

Definition at line 642 of file CondDBESSource.cc.

References b, MillePedeFileConverter_cfg::e, submitPVResolutionJobs::key, m_resolvers, AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

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

◆ isConcurrentFinder()

bool CondDBESSource::isConcurrentFinder ( ) const

inlineoverrideprotectedvirtual

Reimplemented from edm::EventSetupRecordIntervalFinder.

Definition at line 108 of file CondDBESSource.h.

108 { return true; }

◆ printStatistics()

void CondDBESSource::printStatistics ( const Stats & stats ) const

private

Definition at line 354 of file CondDBESSource.cc.

References gather_cfg::cout, and dqmMemoryStats::stats.

Referenced by ~CondDBESSource().

                                                              {
   std::cout << "CondDBESSource Statistics\n"
             << "DataProxy " << stats.nData << " setInterval " << stats.nSet << " Runs " << stats.nRun << " Lumis "
             << stats.nLumi << " Refresh " << stats.nRefresh << " Actual Refresh " << stats.nActualRefresh
             << " Reconnect " << stats.nReconnect << " Actual Reconnect " << stats.nActualReconnect << std::endl;
 }

◆ registerResolvers()

edm::eventsetup::ESProductResolverProvider::KeyedResolversVector CondDBESSource::registerResolvers	(	const EventSetupRecordKey &	iRecordKey,
		unsigned int	iovIndex
	)

overrideprotectedvirtual

Implements edm::eventsetup::ESProductResolverProvider.

Definition at line 618 of file CondDBESSource.cc.

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

                                                                   {
   KeyedResolversVector keyedResolversVector;
 
   std::string recordname = iRecordKey.name();
 
   ResolverMap::const_iterator b = m_resolvers.lower_bound(recordname);
   ResolverMap::const_iterator e = m_resolvers.upper_bound(recordname);
   if (b == e) {
     edm::LogInfo("CondDBESSource") << "No ProductResolver (Pluging) found for record \"" << recordname
                                    << "\"; from CondDBESSource::registerResolvers";
     return keyedResolversVector;
   }
 
   for (ResolverMap::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()));
       keyedResolversVector.emplace_back(key, (*p).second->esResolver(iovIndex));
     }
   }
   return keyedResolversVector;
 }

◆ setIntervalFor()

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

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 404 of file CondDBESSource.cc.

References edm::IOVSyncValue::beginOfTime(), cond::persistency::ConnectionPool::createReadOnlySession(), cond::TimeTypeSpecs::endValue, edm::IOVSyncValue::eventID(), edm::ValidityInterval::first(), cond::time::fromIOVSyncValue(), ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), edm::ValidityInterval::invalidInterval(), edm::IOVSyncValue::invalidIOVSyncValue(), edm::ValidityInterval::last(), cond::time::limitedIOVSyncValue(), edm::IOVSyncValue::luminosityBlockNumber(), m_connection, m_connectionString, m_frontierKey, m_lastLumi, m_lastRecordRuns, m_lastRun, m_mutex, m_policy, m_refreshTimeForRecord, m_resolvers, m_sessionPool, m_sessionPoolForLumiConditions, m_stats, m_tagCollection, genParticles_cff::map, SiStripPI::max, cond::time::MAX_VAL(), SiStripPI::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, cond::time::tillTimeForIOV(), edm::IOVSyncValue::time(), cond::TIMELIMIT(), AlCaHarvesting_cff::timetype, cond::timeTypeNames(), cond::timeTypeSpecs, to_string(), cond::time::toIOVSyncValue(), cond::time::transactionIdForLumiTime(), and edm::Timestamp::value().

                                                                     {
   std::string recordname = iKey.name();
 
   edm::LogInfo("CondDBESSource") << "Getting data for record \"" << recordname
                                  << "\" to be consumed on Run: " << iTime.eventID().run()
                                  << " - Lumiblock:" << iTime.luminosityBlockNumber()
                                  << " - Timestamp: " << iTime.time().value() << "; from CondDBESSource::setIntervalFor";
 
   std::lock_guard<std::mutex> guard(m_mutex);
   m_stats.nSet++;
 
   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++;
   }
 
   bool doRefresh = false;
   cond::Time_t defaultIovSize = cond::time::MAX_VAL;
   bool refreshThisRecord = false;
   bool reconnectThisRecord = false;
 
   auto iR = m_refreshTimeForRecord.find(recordname);
   refreshThisRecord = iR != m_refreshTimeForRecord.end();
   if (refreshThisRecord) {
     defaultIovSize = iR->second.first;
     reconnectThisRecord = iR->second.second;
     iR->second.second = false;
   }
 
   if (m_policy == REFRESH_EACH_RUN || m_policy == RECONNECT_EACH_RUN) {
     // find out the last run number for the proxy of the specified record
     std::map<std::string, unsigned int>::iterator iRec = m_lastRecordRuns.find(recordname);
     if (iRec != m_lastRecordRuns.end()) {
       cond::Time_t lastRecordRun = iRec->second;
       if (lastRecordRun != m_lastRun) {
         // a refresh is required!
         doRefresh = true;
         iRec->second = m_lastRun;
         edm::LogInfo("CondDBESSource") << "Preparing refresh for record \"" << recordname
                                        << "\" since there has been a transition from run/lumi " << lastRecordRun
                                        << " to run/lumi " << m_lastRun << "; from CondDBESSource::setIntervalFor";
       }
     } else {
       doRefresh = true;
       m_lastRecordRuns.insert(std::make_pair(recordname, m_lastRun));
       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
   ResolverMap::const_iterator pmBegin = m_resolvers.lower_bound(recordname);
   ResolverMap::const_iterator pmEnd = m_resolvers.upper_bound(recordname);
   if (pmBegin == pmEnd) {
     edm::LogInfo("CondDBESSource") << "No ProductResolver (Pluging) found for record \"" << recordname
                                    << "\"; from CondDBESSource::setIntervalFor";
     return;
   }
 
   for (ResolverMap::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 || refreshThisRecord) {
       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 || reconnectThisRecord) {
         edm::LogInfo("CondDBESSource")
             << "Checking if the session must be closed and re-opened for getting correct conditions"
             << "; from CondDBESSource::setIntervalFor";
         std::string transId;
         if (!reconnectThisRecord) {
           transId = std::to_string(abtime);
         } else {
           transId = cond::time::transactionIdForLumiTime(abtime, defaultIovSize, 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) {
             // the available session is open for a different run: reopen
             reopen = true;
             iSess->second.second = transId;
           }
         } else {
           // no available session: probably first run analysed...
           iSess =
               sessionPool->insert(std::make_pair(connStr, std::make_pair(cond::persistency::Session(), transId))).first;
           reopen = true;
         }
         if (reopen) {
           iSess->second.first = m_connection.createReadOnlySession(connStr, transId);
           edm::LogInfo("CondDBESSource") << "Re-opening the session with connection string " << connStr
                                          << " and new transaction Id " << transId
                                          << "; 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();
         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();
         m_stats.nRefresh++;
       }
     }
 
     //query the IOVSequence
     cond::ValidityInterval validity = (*pmIter).second->setIntervalFor(abtime);
 
     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 (refreshThisRecord && recordValidity.second == cond::TIMELIMIT) {
       iR->second.second = true;
       if (defaultIovSize)
         recordValidity.second = cond::time::tillTimeForIOV(abtime, defaultIovSize, timetype);
       else {
         recordValidity.second = 0;
       }
     }
   }
 
   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";
 }

Member Data Documentation

◆ m_connection

cond::persistency::ConnectionPool CondDBESSource::m_connection

private

Definition at line 113 of file CondDBESSource.h.

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

◆ m_connectionString

std::string CondDBESSource::m_connectionString

private

Definition at line 114 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_doDump

bool CondDBESSource::m_doDump

private

Definition at line 148 of file CondDBESSource.h.

Referenced by ~CondDBESSource().

◆ m_frontierKey

std::string CondDBESSource::m_frontierKey

private

Definition at line 115 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_jsonDumpFilename

std::string CondDBESSource::m_jsonDumpFilename

Definition at line 96 of file CondDBESSource.h.

Referenced by ~CondDBESSource().

◆ m_lastLumi

unsigned int CondDBESSource::m_lastLumi

private

Definition at line 145 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_lastRecordRuns

std::map<std::string, unsigned int> CondDBESSource::m_lastRecordRuns

private

Definition at line 126 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_lastRun

unsigned int CondDBESSource::m_lastRun

private

Definition at line 144 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_mutex

std::mutex CondDBESSource::m_mutex

private

Definition at line 129 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_policy

RefreshPolicy CondDBESSource::m_policy

private

Definition at line 146 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_queue

edm::SerialTaskQueue CondDBESSource::m_queue

private

Definition at line 128 of file CondDBESSource.h.

Referenced by CondDBESSource().

◆ m_refreshTimeForRecord

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

private

Definition at line 123 of file CondDBESSource.h.

Referenced by CondDBESSource(), and setIntervalFor().

◆ m_resolvers

ResolverMap CondDBESSource::m_resolvers

private

Definition at line 118 of file CondDBESSource.h.

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

◆ m_sessionPool

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

private

Definition at line 124 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 125 of file CondDBESSource.h.

Referenced by setIntervalFor().

◆ m_stats

Stats CondDBESSource::m_stats

private

Definition at line 142 of file CondDBESSource.h.

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

◆ m_tagCollection

TagCollection CondDBESSource::m_tagCollection

private

Definition at line 122 of file CondDBESSource.h.

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

Classes

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ DataKey

◆ EventSetupRecordKey

◆ ResolverMap

◆ ResolverP

◆ TagCollection

Member Enumeration Documentation

◆ RefreshPolicy

Constructor & Destructor Documentation

◆ CondDBESSource()

◆ ~CondDBESSource()

Member Function Documentation

◆ fillList()

◆ fillTagCollectionFromDB()

◆ fillTagCollectionFromGT()

◆ initConcurrentIOVs()

◆ isConcurrentFinder()

◆ printStatistics()

◆ registerResolvers()

◆ setIntervalFor()

Member Data Documentation

◆ m_connection

◆ m_connectionString

◆ m_doDump

◆ m_frontierKey

◆ m_jsonDumpFilename

◆ m_lastLumi

◆ m_lastRecordRuns

◆ m_lastRun

◆ m_mutex

◆ m_policy

◆ m_queue

◆ m_refreshTimeForRecord

◆ m_resolvers

◆ m_sessionPool

◆ m_sessionPoolForLumiConditions

◆ m_stats

◆ m_tagCollection