#include <CondDBESSource.h>

Inheritance diagram for CondDBESSource:

Classes
struct	Stats

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

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

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

Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair < DataKey, boost::shared_ptr < DataProxy > > >	KeyedProxies

typedef std::vector < EventSetupRecordKey >	Keys

typedef std::map < EventSetupRecordKey, KeyedProxies >	RecordProxies

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

	~CondDBESSource ()

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider ()

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

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

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

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder ()

Protected Member Functions
virtual void	newInterval (const edm::eventsetup::EventSetupRecordKey &iRecordType, const edm::ValidityInterval &iInterval)
	called when a new interval of validity occurs for iRecordType More...

virtual void	registerProxies (const edm::eventsetup::EventSetupRecordKey &iRecordKey, KeyedProxies &aProxyList)

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

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

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

unsigned int	m_lastLumi

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

unsigned int	m_lastRun

RefreshPolicy	m_policy

ProxyMap	m_proxies

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

Stats	m_stats

TagCollection	m_tagCollection

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

Detailed Description

Definition at line 32 of file CondDBESSource.h.

Member Typedef Documentation

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

Definition at line 36 of file CondDBESSource.h.

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

Definition at line 35 of file CondDBESSource.h.

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

private

Definition at line 64 of file CondDBESSource.h.

Member Enumeration Documentation

enum CondDBESSource::RefreshPolicy

Enumerator
NOREFRESH
REFRESH_ALWAYS
REFRESH_OPEN_IOVS
REFRESH_EACH_RUN
RECONNECT_EACH_RUN

Definition at line 38 of file CondDBESSource.h.

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

CondDBESSource::RECONNECT_EACH_RUN

Definition: CondDBESSource.h:38

CondDBESSource::REFRESH_EACH_RUN

Definition: CondDBESSource.h:38

CondDBESSource::REFRESH_ALWAYS

Definition: CondDBESSource.h:38

CondDBESSource::NOREFRESH

Definition: CondDBESSource.h:38

CondDBESSource::REFRESH_OPEN_IOVS

Definition: CondDBESSource.h:38

CondDBESSource::RefreshPolicy

RefreshPolicy

Definition: CondDBESSource.h:38

Constructor & Destructor Documentation

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

explicit

required by eventsetup

Definition at line 101 of file CondDBESSource.cc.

References b, cond::persistency::ConnectionPool::configure(), cond::persistency::convertoToOracleConnection(), cond::persistency::ConnectionPool::createReadOnlySession(), alignCSCRings::e, edm::ParameterSet::exists(), fillList(), fillTagCollectionFromDB(), edm::EventSetupRecordIntervalFinder::findingRecordWithKey(), edm::eventsetup::heterocontainer::HCTypeTag::findType(), cond::persistency::fullyQualifiedTag(), reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), align_cfg::globaltag, m_connection, m_connectionString, m_policy, m_proxies, m_stats, m_tagCollection, cond::time::MAX_TIMESTAMP, CondDBESSource::Stats::nData, cond::persistency::parseConnectionString(), cond::persistency::parseTag(), dbtoconf::pfn, RECONNECT_EACH_RUN, REFRESH_ALWAYS, REFRESH_EACH_RUN, REFRESH_OPEN_IOVS, alignCSCRings::s, cond::persistency::ConnectionPool::setParameters(), cond::GTMetadata_t::snapshotTime, split, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, convertSQLitetoXML_cfg::toGet, edm::eventsetup::EventSetupRecordKey::type(), and edm::eventsetup::DataProxyProvider::usingRecordWithKey().

                                                                :
   m_connection(), 
   m_connectionString(""),
   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");
   } else if( iConfig.exists("connect") ) // default connection string
     m_connectionString= iConfig.getParameter<std::string>("connect");
 
   // 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" ) );
       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<cond::DataProxyWrapperBase *> proxyWrappers(m_tagCollection.size());
   size_t ipb=0;
   for(it=itBeg;it!=itEnd;++it){
     proxyWrappers[ipb++] =  
       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(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);
   }
 
   // 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()->loadMore( visitor );
 
     edm::eventsetup::EventSetupRecordKey recordKey(edm::eventsetup::EventSetupRecordKey::TypeTag::findType( (*b).first ) );
     if( recordKey.type() != edm::eventsetup::EventSetupRecordKey::TypeTag() ) {
       findingRecordWithKey( recordKey );
       usingRecordWithKey( recordKey );
     }
   }
 
   m_stats.nData=m_proxies.size();
 
 }

CondDBESSource::~CondDBESSource ( )

Definition at line 296 of file CondDBESSource.cc.

References b, gather_cfg::cout, alignCSCRings::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.

                                 {
   //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...
   }
 }

Member Function Documentation

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

private

Definition at line 281 of file CondDBESSource.cc.

References Exception, i, 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" ) );
   }
 }

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

References autoCondHLT::connectionString, Exception, NewTree::fid, fillTagCollectionFromGT(), m_tagCollection, visualization-live-secondInstance_cfg::msg, prof2calltree::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 );
   }
 }

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

References cond::persistency::Transaction::commit(), cond::persistency::ConnectionPool::createSession(), m_connection, cond::persistency::parseConnectionString(), cond::persistency::Session::readGlobalTag(), python.CommonUtils::session, 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();
   }
 }

void CondDBESSource::newInterval	(	const edm::eventsetup::EventSetupRecordKey &	iRecordType,
		const edm::ValidityInterval &	iInterval
	)

protectedvirtual

called when a new interval of validity occurs for iRecordType

Implements edm::eventsetup::DataProxyProvider.

Definition at line 556 of file CondDBESSource.cc.

References edm::eventsetup::DataProxyProvider::invalidateProxies().

 {
   //LogDebug ("CondDBESSource")<<"newInterval";
   invalidateProxies(iRecordType);
 }

void CondDBESSource::registerProxies	(	const edm::eventsetup::EventSetupRecordKey &	iRecordKey,
		KeyedProxies &	aProxyList
	)

protectedvirtual

Implements edm::eventsetup::DataProxyProvider.

Definition at line 534 of file CondDBESSource.cc.

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

                                                                                                              {
   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;
   }
 
   for (ProxyMap::const_iterator p=b;p!=e;++p) {  
     if(0 != (*p).second.get()) {
       edm::eventsetup::TypeTag type =  (*p).second->type(); 
       edm::eventsetup::DataKey key( type, edm::eventsetup::IdTags((*p).second->label().c_str()) );
       aProxyList.push_back(KeyedProxies::value_type(key,(*p).second->edmProxy()));
     }
   }
 }

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

protectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 329 of file CondDBESSource.cc.

References cond::persistency::ConnectionPool::createReadOnlySession(), cond::TimeTypeSpecs::endValue, edm::IOVSyncValue::eventID(), edm::ValidityInterval::first(), plotBeamSpotDB::first, cond::time::fromIOVSyncValue(), align::invalid, edm::ValidityInterval::invalidInterval(), edm::ValidityInterval::last(), cond::time::limitedIOVSyncValue(), edm::IOVSyncValue::luminosityBlockNumber(), m_connection, m_connectionString, m_lastLumi, m_lastRecordRuns, m_lastRun, m_policy, m_proxies, m_sessionPool, m_stats, m_tagCollection, python.multivaluedict::map(), bookConverter::max, 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(), dqm_diff::start, AlCaHLTBitMon_QueryRunRegistry::string, edm::IOVSyncValue::time(), cond::TIMELIMIT(), dtNoiseCalibration_cfg::timetype, cond::timeTypeNames(), cond::timeTypeSpecs, cond::time::toIOVSyncValue(), and edm::Timestamp::value().

                                                                                                                                           {
 
   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";
   
   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++;
     }
     //}
  
   bool doRefresh = 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() ){
       unsigned int 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 "
                      << lastRecordRun << " to run " << 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
   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->proxy()->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 ) {
     edm::LogInfo( "CondDBESSource" ) << "Checking if the session must be closed and re-opened for getting correct conditions"
                      << "; from CondDBESSource::setIntervalFor";
     std::stringstream transId;
     //transId << "long" << m_lastRun;
     transId << m_lastRun;
     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> >::iterator iSess = m_sessionPool.find( connStr );
     bool reopen = false;
     if( iSess != m_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 = m_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->proxy()->setUp( iSess->second.first ); 
     pmIter->second->proxy()->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->proxy()->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->proxy()->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( 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);
        
     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";
 }