PoolSvc Class Reference

This class provides the interface to the LCG POOL persistency software. More...

#include <PoolSvc.h>

Inheritance diagram for PoolSvc:

Collaboration diagram for PoolSvc:

Classes
class	ContextLock

Public Member Functions
virtual StatusCode	initialize () override
	Required of all Gaudi services:
virtual StatusCode	io_reinit () override
virtual StatusCode	start () override
	Required of all Gaudi services:
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
	Required of all Gaudi services:
virtual StatusCode	io_finalize () override
virtual Token *	registerForWrite (const Placement *placement, const void *obj, const RootType &classDesc) override
virtual void	setObjPtr (void *&obj, const Token *token) override
virtual unsigned int	getOutputContext (const std::string &label) override
virtual unsigned int	getInputContext (const std::string &label, unsigned int maxFile=0) override
virtual std::map< std::string, unsigned int >	getInputContextMap () const override
virtual unsigned int	getInputContextMapSize () const override
virtual const coral::Context *	context () const override
virtual void	loadComponent (const std::string &compName) override
virtual void	setShareMode (bool shareCat) override
virtual const pool::IFileCatalog *	catalog () const override
virtual void	lookupBestPfn (const std::string &token, std::string &pfn, std::string &type) const override
virtual void	renamePfn (const std::string &pf, const std::string &newpf) override
virtual pool::ICollection *	createCollection (const std::string &collectionType, const std::string &connection, const std::string &collectionName, unsigned int contextId=IPoolSvc::kInputStream) const override
virtual Token *	getToken (const std::string &connection, const std::string &collection, const unsigned long ientry) const override
virtual StatusCode	connect (pool::ITransaction::Type type, unsigned int contextId=IPoolSvc::kInputStream) override
	Connect to a logical database unit; PersistencySvc is chosen according to transaction type (accessmode).
virtual StatusCode	commit (unsigned int contextId=IPoolSvc::kInputStream) const override
	Commit data for a given contextId and flush buffer.
virtual StatusCode	commitAndHold (unsigned int contextId=IPoolSvc::kInputStream) const override
	Commit data for a given contextId and hold buffer.
virtual StatusCode	disconnect (unsigned int contextId=IPoolSvc::kInputStream) const override
	Disconnect PersistencySvc associated with a contextId.
virtual StatusCode	disconnectDb (const std::string &connection, unsigned int contextId=IPoolSvc::kInputStream) const override
	Disconnect single Database.
virtual long long int	getFileSize (const std::string &dbName, long tech, unsigned int contextId) const override
	Get POOL FileSize attribute for database without logging a message.
virtual StatusCode	getAttribute (const std::string &optName, std::string &data, long tech, unsigned int contextId=IPoolSvc::kInputStream) const override
	Get POOL attributes - domain.
virtual StatusCode	getAttribute (const std::string &optName, std::string &data, long tech, const std::string &dbName, const std::string &contName="", unsigned int contextId=IPoolSvc::kInputStream) const override
	Get POOL attributes - db/file, container/collection.
virtual StatusCode	setAttribute (const std::string &optName, const std::string &data, long tech, unsigned int contextId=IPoolSvc::kOutputStream) const override
	Set POOL attributes - domain.
virtual StatusCode	setAttribute (const std::string &optName, const std::string &data, long tech, const std::string &dbName, const std::string &contName="", unsigned int contextId=IPoolSvc::kOutputStream) const override
	Set POOL attributes - db/file, container/collection.
virtual StatusCode	setFrontierCache (const std::string &conn) override
	Setup Frontier cache for given logical or physical connection name.
virtual	~PoolSvc ()
	Destructor.

Private Types
typedef std::recursive_mutex	CallMutex

Private Member Functions
void	clearState ()
pool::IFileCatalog *	createCatalog ()
void	patchCatalog (const std::string &pfn, pool::IDatabase &dbH) const
StatusCode	setupPersistencySvc ()
std::unique_ptr< pool::IDatabase >	getDbHandle (unsigned int contextId, const std::string &dbName) const
	Get Database handle.
std::unique_ptr< pool::IContainer >	getContainerHandle (pool::IDatabase *dbH, const std::string &contName) const
	Get Container handle.
std::string	poolCondPath (const std::string &leaf)
	Resolve a file using ATLAS_POOLCOND_PATH.

Private Attributes
CallMutex	m_pool_mut
coral::Context *	m_context {nullptr}
bool	m_shareCat {false}
pool::IFileCatalog *	m_catalog {nullptr}
std::vector< pool::IPersistencySvc * >	m_persistencySvcVec
std::vector< CallMutex * >	m_pers_mut
std::map< std::string, unsigned int >	m_inputContextLabel
std::map< std::string, unsigned int >	m_outputContextLabel
std::string	m_mainOutputLabel {}
std::map< unsigned int, unsigned int >	m_contextMaxFile
std::map< unsigned int, std::list< Guid > > m_guidLists	ATLAS_THREAD_SAFE
Gaudi::Property< std::string >	m_fileOpen {this,"FileOpen","overwrite"}
	FileOpen, the open mode for the file ("append" or "overwrite").
Gaudi::Property< int >	m_dbAgeLimit {this,"MaxFilesOpen",0}
	MaxFilesOpen, option to have PoolSvc limit the number of open Input Files: default = 0 (No files are closed automatically)
Gaudi::Property< std::string >	m_writeCatalog {this,"WriteCatalog","xmlcatalog_file:PoolFileCatalog.xml"}
	WriteCatalog, the file catalog to be used to register output files (also default input catalog): default = "" (use POOL default).
Gaudi::Property< std::vector< std::string > >	m_readCatalog {this,"ReadCatalog",{},"List of catalog files to read from","OrderedSet<std::string>"}
	ReadCatalog, the list of additional POOL input file catalogs to consult: default = empty vector.
Gaudi::Property< bool >	m_useROOTIMT {this,"UseROOTImplicitMT",true}
	Use ROOT Implicit MultiThreading, default = true.
Gaudi::Property< bool >	m_useROOTMaxTree {this,"UseROOTIncreaseVMaxTree",false}
	Increase virtual TTree size to avoid backreads in multithreading, default = false.
Gaudi::Property< bool >	m_attemptCatalogPatch {this,"AttemptCatalogPatch",true}
	AttemptCatalogPatch, option to create catalog: default = false.
Gaudi::Property< int >	m_retrialPeriod {this,"ConnectionRetrialPeriod",300}
	ConnectionRetrialPeriod, retry period for CORAL Connection Service: default = 30 seconds.
Gaudi::Property< int >	m_retrialTimeOut {this,"ConnectionRetrialTimeOut",3600}
	ConnectionRetrialTimeOut, the retrial time out for CORAL Connection Service: default = 300 seconds.
Gaudi::Property< int >	m_timeOut {this,"ConnectionTimeOut",5}
	ConnectionTimeOut, the time out for CORAL Connection Service: default = 5 seconds.
Gaudi::Property< bool >	m_connClean {this,"ConnectionCleanUp",false}
	ConnectionCleanUp - whether to use CORAL connection management thread: default = false.
Gaudi::Property< int >	m_frontierComp {this,"FrontierCompression",5}
	Frontier proprties, compression level and list of schemas to be refreshed: default = 5.
Gaudi::Property< std::vector< std::string > >	m_frontierRefresh {this,"FrontierRefreshSchema",{}}
Gaudi::Property< bool >	m_sortReplicas {this,"SortReplicas",true}
	Use DBReplicaSvc to sort database connections, default = true.
Gaudi::Property< std::string >	m_defaultROOTContainerType {this, "DefaultContainerType", "ROOTTREEINDEX"}
	Default ROOT container type.

Detailed Description

This class provides the interface to the LCG POOL persistency software.

Definition at line 36 of file PoolSvc.h.

Member Typedef Documentation

CallMutex

typedef std::recursive_mutex PoolSvc::CallMutex

private

Definition at line 209 of file PoolSvc.h.

Constructor & Destructor Documentation

~PoolSvc()

PoolSvc::~PoolSvc ( )

virtual

Destructor.

Definition at line 955 of file PoolSvc.cxx.

                  {
}

Member Function Documentation

catalog()

const pool::IFileCatalog * PoolSvc::catalog ( ) const

overridevirtual

Returns

the file catalog.

Definition at line 406 of file PoolSvc.cxx.

                                               {
   return(m_catalog);
}

clearState()

void PoolSvc::clearState ( )

private

Definition at line 239 of file PoolSvc.cxx.

                         {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   // Cleanup persistency service
   for (const auto& persistencySvc : m_persistencySvcVec) {
      delete persistencySvc;
   }
   m_persistencySvcVec.clear();
   for (const auto& persistencyMutex : m_pers_mut) {
      delete persistencyMutex;
   }
   m_mainOutputLabel.clear();
   m_inputContextLabel.clear();
   m_outputContextLabel.clear();
   m_pers_mut.clear();
   if (m_catalog != nullptr) {
      m_catalog->commit();
      delete m_catalog; m_catalog = nullptr;
   }
}

commit()

StatusCode PoolSvc::commit ( unsigned int contextId = IPoolSvc::kInputStream ) const

overridevirtual

Commit data for a given contextId and flush buffer.

Parameters

contextId

[IN] poolStream to be commited.

Definition at line 595 of file PoolSvc.cxx.

                                                       {
   if (contextId >= m_persistencySvcVec.size()) {
      return(StatusCode::FAILURE);
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   pool::IPersistencySvc* persSvc = m_persistencySvcVec[contextId];
   if (persSvc != nullptr && persSvc->session().transaction().isActive()) {
      if (!persSvc->session().transaction().commit()) {
         ATH_MSG_ERROR("POOL commit failed " << persSvc);
         return(StatusCode::FAILURE);
      }
      if (persSvc->session().transaction().type() == pool::ITransaction::READ) {
         persSvc->session().disconnectAll();
      }
   }
   return(StatusCode::SUCCESS);
}

commitAndHold()

StatusCode PoolSvc::commitAndHold ( unsigned int contextId = IPoolSvc::kInputStream ) const

overridevirtual

Commit data for a given contextId and hold buffer.

Parameters

contextId

[IN] poolStream to be commited.

Definition at line 613 of file PoolSvc.cxx.

                                                              {
   if (contextId >= m_persistencySvcVec.size()) {
      return(StatusCode::FAILURE);
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   pool::IPersistencySvc* persSvc = m_persistencySvcVec[contextId];
   if (persSvc != nullptr && persSvc->session().transaction().isActive()) {
      if (!persSvc->session().transaction().commitAndHold()) {
         ATH_MSG_ERROR("POOL commitAndHold failed " << persSvc);
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

connect()

StatusCode PoolSvc::connect ( pool::ITransaction::Type type, unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Connect to a logical database unit; PersistencySvc is chosen according to transaction type (accessmode).

Definition at line 563 of file PoolSvc.cxx.

                                                                             {
   if (type != pool::ITransaction::READ) {
      if (contextId >= m_persistencySvcVec.size()) {
         ATH_MSG_WARNING("connect: Using default output Stream instead of id = " << contextId);
         contextId = IPoolSvc::kOutputStream;
      }
   } else {
      if (contextId > m_persistencySvcVec.size()) {
         ATH_MSG_WARNING("connect: Using default input Stream instead of id = " << contextId);
         contextId = IPoolSvc::kInputStream;
      } else if (contextId == m_persistencySvcVec.size()) {
         ATH_MSG_INFO("Connecting to InputStream for: " << contextId);
         contextId = this->getInputContext("");
      }
   }
   if (contextId >= m_persistencySvcVec.size()) {
      return(StatusCode::FAILURE);
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   pool::IPersistencySvc* persSvc = m_persistencySvcVec[contextId];
   // Connect to a logical database using the pre-defined technology and dbID
   if (persSvc->session().transaction().isActive()) {
      return(StatusCode::SUCCESS);
   }
   if (!persSvc->session().transaction().start(type)) {
      ATH_MSG_ERROR("connect failed persSvc = " << persSvc << " type = " << type);
      return(StatusCode::FAILURE);
   }
 
   return(StatusCode::SUCCESS);
}

context()

const coral::Context * PoolSvc::context ( ) const

overridevirtual

Returns

the context.

Definition at line 394 of file PoolSvc.cxx.

                                           {
   return(m_context);
}

createCatalog()

pool::IFileCatalog * PoolSvc::createCatalog ( )

private

Definition at line 915 of file PoolSvc.cxx.

                                         {
   pool::IFileCatalog* ctlg = new pool::IFileCatalog;
   ctlg->removeCatalog("*");
   for (auto& catalog : m_readCatalog.value()) {
      ATH_MSG_DEBUG("POOL ReadCatalog is " << catalog);
      if (catalog.compare(0, 8,"apcfile:") == 0 || catalog.compare(0, 7, "prfile:") == 0) {
         std::string::size_type cpos = catalog.find(':');
         // check for file accessed via ATLAS_POOLCOND_PATH
         std::string file = poolCondPath(catalog.substr(cpos + 1));
         if (!file.empty()) {
            ATH_MSG_INFO("Resolved path (via ATLAS_POOLCOND_PATH) is " << file);
            ctlg->addReadCatalog("file:" + file);
         } else {
            // As backup, check for file accessed via PathResolver
            file = PathResolver::find_file(catalog.substr(cpos + 1), "DATAPATH");
            if (!file.empty()) {
               ATH_MSG_INFO("Resolved path (via DATAPATH) is " << file);
               ctlg->addReadCatalog("file:" + file);
            } else {
               ATH_MSG_INFO("Unable find catalog "
                   << catalog
                   << " in $ATLAS_POOLCOND_PATH and $DATAPATH");
            }
         }
      } else {
         ctlg->addReadCatalog(catalog);
      }
   }
   try {
      ATH_MSG_INFO("POOL WriteCatalog is " << m_writeCatalog.value());
      ctlg->setWriteCatalog(m_writeCatalog.value());
      ctlg->connect();
   } catch(std::exception& e) {
      ATH_MSG_ERROR("setWriteCatalog - caught exception: " << e.what());
      return(nullptr); // This catalog is not setup properly!
   }
   return(ctlg);
}

createCollection()

pool::ICollection * PoolSvc::createCollection ( const std::string & collectionType, const std::string & connection, const std::string & collectionName, unsigned int contextId = IPoolSvc::kInputStream ) const

overridevirtual

Returns

a pointer to a Pool Collection.

Parameters

collectionType	[IN] string containing the collection type.
connection	[IN] string containing the connection.
collectionName	[IN] string containing the persistent name of the collection.
contextId	[IN] id for PoolSvc persistency service to use for input.

Definition at line 443 of file PoolSvc.cxx.

                                      {
   ATH_MSG_DEBUG("createCollection() type=" << collectionType << ", connection=" << connection
                 << ", name=" << collectionName << ", contextID=" << contextId);
   if (contextId >= m_persistencySvcVec.size()) {
      ATH_MSG_WARNING("createCollection: Using default input Stream instead of id = " << contextId);
      contextId = IPoolSvc::kInputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   // Check POOL FileCatalog entry.
   bool insertFile = false;
   if (connection.compare(0, 4, "PFN:") == 0) {
      std::string fid, fileType;
      m_catalog->lookupFileByPFN(connection.substr(4), fid, fileType);
      if (fid.empty()) { // No entry in file catalog
         insertFile = true;
         ATH_MSG_INFO("File is not in Catalog! Attempt to open it anyway.");
      }
   }
   if (collectionType == "ImplicitCollection") {
      // Check whether Collection Container exists.
      std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
      if (dbH == nullptr) {
         ATH_MSG_INFO("Failed to get Session/DatabaseHandle to create POOL collection.");
         return(nullptr);
      }
      try {
         if (dbH->openMode() == pool::IDatabase::CLOSED) {
            dbH->connectForRead();
         }
         std::map<unsigned int, unsigned int>::const_iterator maxFileIter = m_contextMaxFile.find(contextId);
         if (maxFileIter != m_contextMaxFile.end() && maxFileIter->second > 0 && !dbH->fid().empty()) {
            const Guid guid(dbH->fid());
            m_guidLists[contextId].remove(guid);
            m_guidLists[contextId].push_back(guid);
            while (m_guidLists[contextId].size() > maxFileIter->second + 1) {
               this->disconnectDb("FID:" + m_guidLists[contextId].begin()->toString(), contextId).ignore();
            }
         }
      } catch (std::exception& e) {
         ATH_MSG_INFO("Failed to open container to check POOL collection - trying.");
      }
   }
 
   // access to these variables is locked below:
   pool::CollectionService collSvc ATLAS_THREAD_SAFE = pool::CollectionService();
   pool::ICollection* collPtr ATLAS_THREAD_SAFE = nullptr;
 
   // Try to open APR EventTags Collection in the input file
   std::scoped_lock sc_lock(m_pool_mut);
   std::string error_text;
   try {
      collPtr = collSvc.open(collectionName, collectionType, connection, &m_persistencySvcVec[contextId]->session());
   } catch (std::exception &e) {
      collPtr = nullptr;
      error_text = e.what();
   }
   if( !collPtr ) {
      std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
      if (dbH != nullptr && !dbH->fid().empty()) {
         return(nullptr); // no events
      }
      throw std::runtime_error( "Failed to open APR Collection: " + error_text  + ", PoolSvc::createCollection");
   }
   if (insertFile && m_attemptCatalogPatch.value()) {
      std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
      if (dbH == nullptr) {
         ATH_MSG_INFO("Failed to create FileCatalog entry.");
      } else if (dbH->fid().empty()) {
         ATH_MSG_INFO("Cannot retrieve the FID of an existing POOL database: '"
                      << connection << "' - FileCatalog will NOT be updated.");
      } else {
        patchCatalog(connection.substr(4), *dbH);
      }
   }
   // For multithreaded processing (with multiple events in flight),
   // increase virtual tree size to accomodate back reads
   if (m_useROOTMaxTree && Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
      if (!this->setAttribute("TREE_MAX_VIRTUAL_SIZE", "-1", pool::ROOT_StorageType.type(), connection.substr(4), "CollectionTree", IPoolSvc::kInputStream).isSuccess()) {
         ATH_MSG_WARNING("Failed to increase maximum virtual TTree size.");
      }
   }
 
   return(collPtr);
}

disconnect()

StatusCode PoolSvc::disconnect ( unsigned int contextId = IPoolSvc::kInputStream ) const

overridevirtual

Disconnect PersistencySvc associated with a contextId.

Parameters

contextId

[IN] poolStream to be disconnected.

Definition at line 628 of file PoolSvc.cxx.

                                                           {
   ATH_MSG_DEBUG("Disconnect request for contextId=" << contextId);
   if (contextId >= m_persistencySvcVec.size()) {
      return(StatusCode::SUCCESS);
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   pool::IPersistencySvc* persSvc = m_persistencySvcVec[contextId];
   if (persSvc != nullptr && persSvc->session().transaction().isActive()) {
      if (!commit(contextId).isSuccess()) {
         ATH_MSG_ERROR("disconnect failed to commit " << persSvc);
         return(StatusCode::FAILURE);
      }
      if (persSvc->session().disconnectAll()) {
         ATH_MSG_DEBUG("Disconnected PersistencySvc session");
      } else {
         ATH_MSG_ERROR("disconnect failed to diconnect PersistencySvc");
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

disconnectDb()

StatusCode PoolSvc::disconnectDb ( const std::string & connection, unsigned int contextId = IPoolSvc::kInputStream ) const

overridevirtual

Disconnect single Database.

Parameters

connection	[IN] connection string for Database to be disconnected.
contextId	[IN] context id of database to be disconnected.

Definition at line 650 of file PoolSvc.cxx.

                                                                                          {
   if (contextId >= m_persistencySvcVec.size()) {
      return(StatusCode::SUCCESS);
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
   if (dbH == nullptr) {
      ATH_MSG_ERROR("Failed to get Session/DatabaseHandle.");
      return(StatusCode::FAILURE);
   }
   std::map<unsigned int, unsigned int>::const_iterator maxFileIter = m_contextMaxFile.find(contextId);
   if (maxFileIter != m_contextMaxFile.end() && maxFileIter->second > 0) {
      m_guidLists[contextId].remove(Guid(dbH->fid()));
   }
   dbH->disconnect();
   return(StatusCode::SUCCESS);
}

finalize()

StatusCode PoolSvc::finalize ( )

overridevirtual

Required of all Gaudi services:

Definition at line 259 of file PoolSvc.cxx.

                             {
   clearState();
   return(::AthService::finalize());
}

getAttribute() [1/2]

StatusCode PoolSvc::getAttribute ( const std::string & optName, std::string & data, long tech, const std::string & dbName, const std::string & contName = "", unsigned int contextId = IPoolSvc::kInputStream ) const

overridevirtual

Get POOL attributes - db/file, container/collection.

Definition at line 709 of file PoolSvc.cxx.

                                      {
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, dbName);
   if (dbH == nullptr) {
      ATH_MSG_DEBUG("getAttribute: Failed to get Session/DatabaseHandle to get POOL property.");
      return(StatusCode::FAILURE);
   }
   if (dbH->openMode() == pool::IDatabase::CLOSED) {
      if (m_persistencySvcVec[contextId]->session().defaultConnectionPolicy().writeModeForNonExisting() != pool::DatabaseConnectionPolicy::RAISE_ERROR) {
         dbH->setTechnology(tech);
         dbH->connectForWrite();
      } else {
         dbH->connectForRead();
      }
   }
   std::ostringstream oss;
   if (contName.empty()) {
      if (data == "DbLonglong") {
         oss << std::dec << dbH->technologySpecificAttributes().attribute<long long int>(optName);
      } else if (data == "double") {
         oss << std::dec << dbH->technologySpecificAttributes().attribute<double>(optName);
      } else if (data == "string") {
         oss << dbH->technologySpecificAttributes().attribute<char*>(optName);
      } else {
         oss << std::dec << dbH->technologySpecificAttributes().attribute<int>(optName);
      }
      ATH_MSG_INFO("Database (" << dbH->pfn() << ") attribute [" << optName << "]" << ": " << oss.str());
   } else {
      std::unique_ptr<pool::IContainer> contH = getContainerHandle(dbH.get(), contName);
      if (contH == nullptr) {
         ATH_MSG_DEBUG("Failed to get ContainerHandle to get POOL property.");
         return(StatusCode::FAILURE);
      }
      if (data == "DbLonglong") {
         oss << std::dec << contH->technologySpecificAttributes().attribute<long long int>(optName);
      } else if (data == "double") {
         oss << std::dec << contH->technologySpecificAttributes().attribute<double>(optName);
      } else {
         oss << std::dec << contH->technologySpecificAttributes().attribute<int>(optName);
      }
      ATH_MSG_INFO("Container attribute [" << contName << "." << optName << "]: " << oss.str());
   }
   data = oss.str();
   return(StatusCode::SUCCESS);
}

getAttribute() [2/2]

StatusCode PoolSvc::getAttribute ( const std::string & optName, std::string & data, long tech, unsigned int contextId = IPoolSvc::kInputStream ) const

overridevirtual

Get POOL attributes - domain.

Definition at line 686 of file PoolSvc.cxx.

                                      {
   if (contextId >= m_persistencySvcVec.size()) {
      ATH_MSG_WARNING("getAttribute: Using default input Stream instead of id = " << contextId);
      contextId = IPoolSvc::kInputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   pool::ISession& sesH = m_persistencySvcVec[contextId]->session();
   std::ostringstream oss;
   if (data == "DbLonglong") {
      oss << std::dec << sesH.technologySpecificAttributes(tech).attribute<long long int>(optName);
   } else if (data == "double") {
      oss << std::dec << sesH.technologySpecificAttributes(tech).attribute<double>(optName);
   } else {
      oss << std::dec << sesH.technologySpecificAttributes(tech).attribute<int>(optName);
   }
   data = oss.str();
   ATH_MSG_INFO("Domain attribute [" << optName << "]" << ": " << data);
   return(StatusCode::SUCCESS);
}

getContainerHandle()

std::unique_ptr< pool::IContainer > PoolSvc::getContainerHandle ( pool::IDatabase * dbH, const std::string & contName ) const

private

Get Container handle.

Definition at line 985 of file PoolSvc.cxx.

                                                                                                             {
   pool::IContainer* contH = nullptr;
   if (dbH == nullptr) {
      ATH_MSG_DEBUG("No DatabaseHandle to get Container.");
      return(nullptr);
   }
   if (dbH->openMode() == pool::IDatabase::CLOSED) {
      dbH->connectForRead();
   }
   if (contName.find("DataHeader") != std::string::npos) {
      contH = dbH->containerHandle(contName.substr(0, contName.find("_p")));
   } else {
      contH = dbH->containerHandle(contName);
   }
   return(std::unique_ptr<pool::IContainer>(contH));
}

getDbHandle()

std::unique_ptr< pool::IDatabase > PoolSvc::getDbHandle ( unsigned int contextId, const std::string & dbName ) const

private

Get Database handle.

Definition at line 958 of file PoolSvc.cxx.

                                                                                                       {
   if (contextId >= m_persistencySvcVec.size()) {
      ATH_MSG_WARNING("getDbHandle: Using default input Stream instead of id = " << contextId);
      contextId = IPoolSvc::kInputStream;
   }
   pool::ISession& sesH = m_persistencySvcVec[contextId]->session();
   if (!sesH.transaction().isActive()) {
      pool::ITransaction::Type transMode = pool::ITransaction::READ;
      if (m_persistencySvcVec[contextId]->session().defaultConnectionPolicy().writeModeForNonExisting() != pool::DatabaseConnectionPolicy::RAISE_ERROR) {
         transMode = pool::ITransaction::UPDATE;
      }
      ATH_MSG_DEBUG("Start transaction, type = " << transMode);
      if (!sesH.transaction().start(transMode)) {
         ATH_MSG_WARNING("Failed to start transaction, type = " << transMode);
         return(nullptr);
      }
   }
   if (dbName.compare(0, 4,"PFN:") == 0) {
      return sesH.databaseHandle(dbName.substr(4), pool::DatabaseSpecification::PFN);
   } else if (dbName.compare(0, 4, "LFN:") == 0) {
      return sesH.databaseHandle(dbName.substr(4), pool::DatabaseSpecification::LFN);
   } else if (dbName.compare(0, 4,"FID:") == 0) {
      return sesH.databaseHandle(dbName.substr(4), pool::DatabaseSpecification::FID);
   } 
   return sesH.databaseHandle(dbName, pool::DatabaseSpecification::PFN);
}

getFileSize()

long long int PoolSvc::getFileSize ( const std::string & dbName, long tech, unsigned int contextId ) const

overridevirtual

Get POOL FileSize attribute for database without logging a message.

Definition at line 668 of file PoolSvc.cxx.

                                                                                                   {
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, dbName);
   if (dbH == nullptr) {
      ATH_MSG_DEBUG("getFileSize: Failed to get Session/DatabaseHandle to get POOL FileSize property.");
      return 0; // failure
   }
   if (dbH->openMode() == pool::IDatabase::CLOSED) {
      if (m_persistencySvcVec[contextId]->session().defaultConnectionPolicy().writeModeForNonExisting() != pool::DatabaseConnectionPolicy::RAISE_ERROR) {
         dbH->setTechnology(tech);
         dbH->connectForWrite();
      } else {
         dbH->connectForRead();
      }
   }
   return(dbH->technologySpecificAttributes().attribute<long long int>("FILE_SIZE"));
}

getInputContext()

unsigned int PoolSvc::getInputContext ( const std::string & label, unsigned int maxFile = 0 )

overridevirtual

Returns

an Id for an input context (POOL persistency service) and create it if needed.

Parameters

label	[IN] string label to name new context and allow sharing (returns existing contextId)
maxFile	[IN] maximum number of open input files.

Definition at line 359 of file PoolSvc.cxx.

                                                                                  {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   if (!label.empty()) {
      std::map<std::string, unsigned int>::const_iterator contextIter = m_inputContextLabel.find(label);
      if (contextIter != m_inputContextLabel.end()) {
         if (maxFile > 0) {
            m_contextMaxFile[contextIter->second] = maxFile;
         }
         return(contextIter->second);
      }
   }
   const unsigned int id = m_persistencySvcVec.size();
   m_persistencySvcVec.push_back( pool::IPersistencySvc::create(*m_catalog).release() );
   m_pers_mut.push_back(new CallMutex);
   if (!connect(pool::ITransaction::READ, id).isSuccess()) {
      ATH_MSG_WARNING("Failed to connect Input PersistencySvc: " << id);
      return(IPoolSvc::kInputStream);
   }
   if (!label.empty()) {
      m_inputContextLabel.insert(std::pair<std::string, unsigned int>(label, id));
   }
   m_contextMaxFile.insert(std::pair<unsigned int, int>(id, maxFile));
   return(id);
}

getInputContextMap()

std::map< std::string, unsigned int > PoolSvc::getInputContextMap ( ) const

overridevirtual

Returns

copy of the map of all labelled input contexts.

Definition at line 384 of file PoolSvc.cxx.

                                                                  {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   return(m_inputContextLabel);
}

getInputContextMapSize()

unsigned int PoolSvc::getInputContextMapSize ( ) const

overridevirtual

Returns

size of the map of all labelled input contexts.

Definition at line 389 of file PoolSvc.cxx.

                                                   {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   return(m_inputContextLabel.size());
}

getOutputContext()

unsigned int PoolSvc::getOutputContext ( const std::string & label )

overridevirtual

Returns

an Id for an output context (POOL persistency service) and create it if needed.

Parameters

label

[IN] string label to name new context and allow sharing (returns existing contextId)

Definition at line 328 of file PoolSvc.cxx.

                                                             {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   if (m_mainOutputLabel.empty()) {
      m_mainOutputLabel = label;
      m_outputContextLabel.insert(std::pair<std::string, unsigned int>(label, IPoolSvc::kOutputStream));
   }
   if (label == m_mainOutputLabel || label.empty()) {
      return(IPoolSvc::kOutputStream);
   }
   std::map<std::string, unsigned int>::const_iterator contextIter = m_outputContextLabel.find(label);
   if (contextIter != m_outputContextLabel.end()) {
      return(contextIter->second);
   }
   const unsigned int id = m_persistencySvcVec.size();
   m_persistencySvcVec.push_back(pool::IPersistencySvc::create(*m_catalog).release());
   m_pers_mut.push_back(new CallMutex);
   pool::DatabaseConnectionPolicy policy;
   policy.setWriteModeForNonExisting(pool::DatabaseConnectionPolicy::CREATE);
   policy.setWriteModeForExisting(pool::DatabaseConnectionPolicy::OVERWRITE);
   if (m_fileOpen.value() == "update") {
      policy.setWriteModeForExisting(pool::DatabaseConnectionPolicy::UPDATE);
   }
   m_persistencySvcVec[id]->session().setDefaultConnectionPolicy(policy);
   if (!m_persistencySvcVec[id]->session().technologySpecificAttributes(pool::ROOT_StorageType.type()).setAttribute<int>("DEFAULT_CONTAINER_TYPE", pool::DbType::getType(m_defaultROOTContainerType).type())) {
      ATH_MSG_WARNING("Failed to set ROOT default container type via PersistencySvc for id " << id);
      return(IPoolSvc::kOutputStream);
   }
   m_outputContextLabel.insert(std::pair<std::string, unsigned int>(label, id));
   return(id);
}

getToken()

Token * PoolSvc::getToken ( const std::string & connection, const std::string & collection, const unsigned long ientry ) const

overridevirtual

Returns

a token for a container entry.

Parameters

connection	[IN] string containing the connection/file name.
collection	[IN] string containing the persistent name of the collection.
ientry	[IN] entry number for the token to be returned

Definition at line 539 of file PoolSvc.cxx.

                                      {
   std::lock_guard<CallMutex> lock(*m_pers_mut[IPoolSvc::kInputStream]);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(IPoolSvc::kInputStream, connection);
   if (dbH == nullptr) {
      return(nullptr);
   }
   if (dbH->openMode() == pool::IDatabase::CLOSED) {
      dbH->connectForRead();
   }
   std::unique_ptr<pool::IContainer> contH = getContainerHandle(dbH.get(), collection);
   if (contH == nullptr) {
      return(nullptr);
   }
   pool::ITokenIterator* tokenIter = contH->tokens();
   Token* thisToken = tokenIter->next();
   for (unsigned long ipos = 0; ipos < ientry; ipos++) {
      delete thisToken; thisToken = tokenIter->next();
   }
   delete tokenIter; tokenIter = nullptr;
   return(thisToken);
}

initialize()

StatusCode PoolSvc::initialize ( )

overridevirtual

Required of all Gaudi services:

Definition at line 57 of file PoolSvc.cxx.

                               {
   ATH_CHECK(::AthService::initialize());
 
   // Register this service for 'I/O' events
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   ATH_CHECK(iomgr.retrieve());
   ATH_CHECK(iomgr->io_register(this));
   // Register input file's names with the I/O manager, unless in SharedWrite mode, set by AthenaPoolCnvSvc
   bool allGood = true;
   for (const auto& catalog : m_readCatalog.value()) {
      if (catalog.starts_with("xmlcatalog_file:")) {
         const std::string fileName = catalog.substr(16);
         if (!iomgr->io_register(this, IIoComponentMgr::IoMode::READ, fileName, fileName).isSuccess()) {
            ATH_MSG_FATAL("could not register [" << catalog << "] for input !");
            allGood = false;
         } else {
            ATH_MSG_INFO("io_register[" << this->name() << "](" << catalog << ") [ok]");
         }
      }
   }
   if (m_writeCatalog.value().starts_with("xmlcatalog_file:")) {
      const std::string fileName = m_writeCatalog.value().substr(16);
      if (!iomgr->io_register(this, IIoComponentMgr::IoMode::WRITE, fileName, fileName).isSuccess()) {
         ATH_MSG_FATAL("could not register [" << m_writeCatalog.value() << "] for input !");
         allGood = false;
      } else {
         ATH_MSG_INFO("io_register[" << this->name() << "](" << m_writeCatalog.value() << ") [ok]");
      }
   }
   if (!allGood) {
      return(StatusCode::FAILURE);
   }
   m_context = &coral::Context::instance();
   if (m_context == nullptr) {
      ATH_MSG_FATAL("Failed to access CORAL Context");
      return(StatusCode::FAILURE);
   }
   coral::ConnectionService conSvcH;
   coral::IConnectionServiceConfiguration& csConfig = conSvcH.configuration();
   csConfig.setConnectionRetrialPeriod(m_retrialPeriod);
   csConfig.setConnectionRetrialTimeOut(m_retrialTimeOut);
   if (m_connClean) {
      csConfig.enablePoolAutomaticCleanUp();
      csConfig.setConnectionTimeOut(m_timeOut);
   } else {
      csConfig.disablePoolAutomaticCleanUp();
      csConfig.setConnectionTimeOut(0);
   }
   ATH_MSG_INFO("Set connectionsvc retry/timeout/IDLE timeout to "
       << m_retrialPeriod
       << "/"
       << m_retrialTimeOut
       << "/"
       << m_timeOut
       << " seconds with connection cleanup "
       << (csConfig.isPoolAutomaticCleanUpEnabled() ? "enabled" : "disabled"));
   // set Frontier web cache compression level
   coral::IWebCacheControl& webCache = conSvcH.webCacheControl();
   webCache.setCompressionLevel(m_frontierComp);
   ATH_MSG_INFO("Frontier compression level set to " << webCache.compressionLevel());
   if (m_sortReplicas) {
      // set replica sorter - get service
      ServiceHandle<IDBReplicaSvc> replicasvc("DBReplicaSvc", name());
      if (replicasvc.retrieve().isSuccess()) {
         csConfig.setReplicaSortingAlgorithm(*replicasvc);
         ATH_MSG_INFO("Successfully setup replica sorting algorithm");
      } else {
         ATH_MSG_WARNING("Cannot setup replica sorting algorithm");
      }
   }
   MSG::Level athLvl = msg().level();
   ATH_MSG_DEBUG("OutputLevel is " << (int)athLvl);
   pool::DbPrintLvl::setLevel(athLvl);
   return(setupPersistencySvc());
}

io_finalize()

StatusCode PoolSvc::io_finalize ( )

overridevirtual

Definition at line 264 of file PoolSvc.cxx.

                                {
   ATH_MSG_INFO("I/O finalization...");
   for (size_t i = 0; i < m_persistencySvcVec.size(); i++) {
      if (m_persistencySvcVec[i]->session().defaultConnectionPolicy().writeModeForNonExisting() != pool::DatabaseConnectionPolicy::RAISE_ERROR &&
          !disconnect(i).isSuccess()) {
         ATH_MSG_WARNING("Cannot disconnect output Stream " << i);
      }
   }
   clearState();
   return(StatusCode::SUCCESS);
}

io_reinit()

StatusCode PoolSvc::io_reinit ( )

overridevirtual

Definition at line 134 of file PoolSvc.cxx.

                              {
   ATH_MSG_INFO("I/O reinitialization...");
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   if (!iomgr.retrieve().isSuccess()) {
      ATH_MSG_FATAL("Could not retrieve IoComponentMgr !");
      return(StatusCode::FAILURE);
   }
   if (!iomgr->io_hasitem(this)) {
      ATH_MSG_FATAL("IoComponentMgr does not know about myself !");
      return(StatusCode::FAILURE);
   }
   std::vector<std::string> readcat = m_readCatalog.value();
   for (std::size_t icat = 0, imax = readcat.size(); icat < imax; icat++) {
      if (readcat[icat].compare(0, 16, "xmlcatalog_file:") == 0) {
         std::string fileName = readcat[icat].substr(16);
         if (iomgr->io_contains(this, fileName)) {
            if (!iomgr->io_retrieve(this, fileName).isSuccess()) {
               ATH_MSG_FATAL("Could not retrieve new value for [" << fileName << "] !");
               return(StatusCode::FAILURE);
            }
            readcat[icat] = "xmlcatalog_file:" + fileName;
         }
      }
   }
   // all good... copy over.
   m_readCatalog = readcat;
   if (m_writeCatalog.value().compare(0, 16, "xmlcatalog_file:") == 0) {
      std::string fileName = m_writeCatalog.value().substr(16);
      if (iomgr->io_contains(this, fileName)) {
         if (!iomgr->io_retrieve(this, fileName).isSuccess()) {
            ATH_MSG_FATAL("Could not retrieve new value for [" << fileName << "] !");
            return(StatusCode::FAILURE);
         }
         if (!m_shareCat) {
            m_writeCatalog.setValue("xmlcatalog_file:" + fileName);
         }
      }
   }
   return(setupPersistencySvc());
}

loadComponent()

void PoolSvc::loadComponent ( const std::string & compName )

overridevirtual

Returns

void

Parameters

compName

[IN] string name of the component to be loaded.

Definition at line 398 of file PoolSvc.cxx.

                                                     {
   m_context->loadComponent(compName);
}

lookupBestPfn()

void PoolSvc::lookupBestPfn ( const std::string & token, std::string & pfn, std::string & type ) const

overridevirtual

Returns

void

Parameters

token	[IN] filename/token string to be translated
pfn	[OUT] string PFN of database
type	[OUT] string filetype of database

Definition at line 410 of file PoolSvc.cxx.

                                                                                         {
   std::string dbID;
   if (token.compare(0, 4, "PFN:") == 0) {
      m_catalog->lookupFileByPFN(token.substr(4), dbID, type); // PFN -> FID
   } else if (token.compare(0, 4, "LFN:") == 0) {
      m_catalog->lookupFileByLFN(token.substr(4), dbID); // LFN -> FID
   } else if (token.compare(0, 4, "FID:") == 0) {
      dbID = token.substr(4);
   } else if (token.size() > Guid::stringSize()) { // full token
      Token tok;
      tok.fromString(token);
      dbID = tok.dbID().toString();
   } else { // guid only
      dbID = token;
   }
   m_catalog->getFirstPFN(dbID, pfn, type); // FID -> best PFN
}

patchCatalog()

void PoolSvc::patchCatalog ( const std::string & pfn, pool::IDatabase & dbH ) const

private

Definition at line 531 of file PoolSvc.cxx.

                                                                         {
   std::scoped_lock lock(m_pool_mut);
   dbH.setTechnology(pool::ROOT_StorageType.type());
   std::string fid = dbH.fid();
   pool::IFileCatalog* catalog_locked ATLAS_THREAD_SAFE = m_catalog;
   catalog_locked->registerPFN(pfn, "ROOT_All", fid);
}

poolCondPath()

std::string PoolSvc::poolCondPath ( const std::string & leaf )

private

Resolve a file using ATLAS_POOLCOND_PATH.

Definition at line 1002 of file PoolSvc.cxx.

                                                     {
   // look for files at $ATLAS_POOLCOND_PATH/<leaf>
   // return full filename if exists, or empty string if not
   const char* cpath = std::getenv("ATLAS_POOLCOND_PATH");
   if (cpath && strcmp(cpath, "") != 0) {
      const std::string testpath = std::string(cpath) + "/" + leaf;
 
      // Try to open file for reading. Note that a simple stat call may return
      // a wrong result if the file is residing on an auto-mounted FS (ATR-28801).
      if (FILE* fp = std::fopen(testpath.c_str(), "r")) {
         std::fclose(fp);
         return testpath;
      }
   }
   return {};
}

registerForWrite()

Token * PoolSvc::registerForWrite ( const Placement * placement, const void * obj, const RootType & classDesc )

overridevirtual

Returns

a token to a Data Object written to Pool.

Parameters

placement	[IN] pointer to the placement hint.
obj	[IN] pointer to the Data Object to be written to Pool.
classDesc	[IN] pointer to the Seal class description for the Data Object.

Definition at line 276 of file PoolSvc.cxx.

                                                            {
   unsigned int contextId = IPoolSvc::kOutputStream;
   const std::string& auxString = placement->auxString();
   if (!auxString.empty()) {
      if (auxString.compare(0, 6, "[CTXT=") == 0) {
         ::sscanf(auxString.c_str(), "[CTXT=%08X]", &contextId);
      } else if (auxString.compare(0, 8, "[CLABEL=") == 0) {
         contextId = this->getOutputContext(auxString);
      }
      if (contextId >= m_persistencySvcVec.size()) {
         ATH_MSG_WARNING("registerForWrite: Using default output Stream instead of id = " << contextId);
         contextId = IPoolSvc::kOutputStream;
      }
   }
   std::lock_guard<CallMutex> lock(*m_pers_mut[contextId]);
   Token* token = m_persistencySvcVec[contextId]->registerForWrite(*placement, obj, classDesc);
   if (token == nullptr) {
      ATH_MSG_WARNING("Cannot write object: " << placement->containerName());
   }
   return(token);
}

renamePfn()

void PoolSvc::renamePfn ( const std::string & pf, const std::string & newpf )

overridevirtual

Returns

void

Parameters

pf	[IN] filename to be renamed
newpf	[IN] new filename

Definition at line 428 of file PoolSvc.cxx.

                                                                   {
   std::string dbID, type;
    m_catalog->lookupFileByPFN(pf, dbID, type);
   if (dbID.empty()) {
      ATH_MSG_WARNING("Failed to lookup: " << pf << " in FileCatalog");
      return;
   }
   m_catalog->lookupFileByPFN(newpf, dbID, type);
   if (!dbID.empty()) {
      ATH_MSG_INFO("Found: " << newpf << " in FileCatalog");
      return;
   }
   m_catalog->renamePFN(pf, newpf);
}

setAttribute() [1/2]

StatusCode PoolSvc::setAttribute ( const std::string & optName, const std::string & data, long tech, const std::string & dbName, const std::string & contName = "", unsigned int contextId = IPoolSvc::kOutputStream ) const

overridevirtual

Set POOL attributes - db/file, container/collection.

Definition at line 784 of file PoolSvc.cxx.

                                      {
   if (contextId >= m_persistencySvcVec.size()) {
      ATH_MSG_WARNING("setAttribute: Using default output Stream instead of id = " << contextId);
      contextId = IPoolSvc::kOutputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, dbName);
   if (dbH == nullptr) {
      ATH_MSG_DEBUG("Failed to get Session/DatabaseHandle to set POOL property.");
      return(StatusCode::FAILURE);
   }
   if (dbH->openMode() == pool::IDatabase::CLOSED) {
      if (m_persistencySvcVec[contextId]->session().defaultConnectionPolicy().writeModeForNonExisting() != pool::DatabaseConnectionPolicy::RAISE_ERROR) {
         dbH->setTechnology(tech);
         dbH->connectForWrite();
      } else {
         dbH->connectForRead();
      }
   }
   bool retError = false;
   std::string objName;
   bool hasTTreeName = (contName.length() > 6 && contName.compare(0, 6, "TTree=") == 0);
   if (contName.empty() || hasTTreeName || m_persistencySvcVec[contextId]->session().defaultConnectionPolicy().writeModeForNonExisting() == pool::DatabaseConnectionPolicy::RAISE_ERROR) {
      objName = hasTTreeName ? contName.substr(6) : contName;
      if( !isNumber(data) ) {
         retError = dbH->technologySpecificAttributes().setAttribute(optName, data.c_str(), objName);
      } else if( data[data.size() - 1] == 'L' ) {
         retError = dbH->technologySpecificAttributes().setAttribute<long long int>(optName, atoll(data.c_str()), objName);
      } else {
         retError = dbH->technologySpecificAttributes().setAttribute<int>(optName, atoi(data.c_str()), objName);
      }
      if (!retError) {
         ATH_MSG_DEBUG("Failed to set POOL property, " << optName << " to " << data);
         return(StatusCode::FAILURE);
      }
   } else {
      std::unique_ptr<pool::IContainer> contH = getContainerHandle(dbH.get(), contName);
      if (contH == nullptr) {
         ATH_MSG_DEBUG("Failed to get ContainerHandle to set POOL property.");
         return(StatusCode::FAILURE);
      }
      if (auto p = contName.find('('); p != std::string::npos) {
         objName = contName.substr(p + 1); // Get BranchName between parenthesis
         objName.erase(objName.find(')'));
      } else if (auto p = contName.find("::"); p != std::string::npos) {
         objName = contName.substr(p + 2); // Split off Tree name
      } else if (auto p = contName.find('_'); p != std::string::npos) {
         objName = contName.substr(p + 1); // Split off "POOLContainer"
         objName.erase(objName.find('/')); // Split off key
      }
      std::string::size_type off = 0;
      while ((off = objName.find_first_of("<>/")) != std::string::npos) {
         objName[off] = '_'; // Replace special chars (e.g. templates)
      }
      if (data[data.size() - 1] == 'L') {
         retError = contH->technologySpecificAttributes().setAttribute<long long int>(optName, atoll(data.c_str()), objName);
      } else {
         retError = contH->technologySpecificAttributes().setAttribute<int>(optName, atoi(data.c_str()), objName);
      }
      if (!retError) {
         ATH_MSG_DEBUG("Failed to set POOL container property, " << optName << " for " << contName << " : " << objName << " to " << data);
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

setAttribute() [2/2]

StatusCode PoolSvc::setAttribute ( const std::string & optName, const std::string & data, long tech, unsigned int contextId = IPoolSvc::kOutputStream ) const

overridevirtual

Set POOL attributes - domain.

Definition at line 760 of file PoolSvc.cxx.

                                      {
   if (contextId >= m_persistencySvcVec.size()) {
      ATH_MSG_WARNING("setAttribute: Using default output Stream instead of id = " << contextId);
      contextId = IPoolSvc::kOutputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   pool::ISession& sesH = m_persistencySvcVec[contextId]->session();
   if (data[data.size() - 1] == 'L') {
      if (!sesH.technologySpecificAttributes(tech).setAttribute<long long int>(optName, atoll(data.c_str()))) {
         ATH_MSG_DEBUG("Failed to set POOL property, " << optName << " to " << data);
         return(StatusCode::FAILURE);
      }
   } else {
      if (!sesH.technologySpecificAttributes(tech).setAttribute<int>(optName, atoi(data.c_str()))) {
         ATH_MSG_DEBUG("Failed to set POOL property, " << optName << " to " << data);
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

setFrontierCache()

StatusCode PoolSvc::setFrontierCache ( const std::string & conn )

overridevirtual

Setup Frontier cache for given logical or physical connection name.

Definition at line 856 of file PoolSvc.cxx.

                                                          {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   ATH_MSG_VERBOSE("setFrontierCache called for connection:" << conn);
   // setup the Frontier cache information for the given logical or physical connection string
   // first determine if the connection is logical (no ':')
   std::vector<std::string> physcons;
   if (conn.find(':') == std::string::npos) {
      // if logical, have to lookup list of physical replicas, and consider each
      // need the CORAL ILookupSvc interface which must be loaded if needed
      const std::string lookSvcStr("CORAL/Services/XMLLookupService");
      coral::IHandle<coral::ILookupService> lookSvcH = m_context->query<coral::ILookupService>();
      if (!lookSvcH.isValid()) {
         m_context->loadComponent(lookSvcStr);
         lookSvcH = m_context->query<coral::ILookupService>();
      }
      if (!lookSvcH.isValid()) {
         ATH_MSG_ERROR("Cannot locate " << lookSvcStr);
         return(StatusCode::FAILURE);
      }
      coral::IDatabaseServiceSet* dbset = lookSvcH->lookup(conn, coral::ReadOnly);
      if (dbset != nullptr) {
         for (int irep = 0, nrep = dbset->numberOfReplicas(); irep < nrep; ++irep) {
        const std::string pcon = dbset->replica(irep).connectionString();
        if (pcon.compare(0, 9, "frontier:") == 0) {
               physcons.push_back(std::move(pcon));
            }
         }
         delete dbset; dbset = nullptr;
      } else {
         ATH_MSG_DEBUG("setFrontierCache: Could not find any replicas for " << conn);
      }
   } else if (conn.compare(0, 9, "frontier:") == 0) {
      physcons.push_back(conn);
   }
   // check if any replicas will try and use frontier
   if (physcons.size() == 0) {
      return(StatusCode::SUCCESS);
   }
   coral::ConnectionService conSvcH;
   // for each frontier replica, define the web cache info
   // get the WebCacheControl interface via ConnectionSvc
   // note ConnectionSvc should already be loaded by initialize
   coral::IWebCacheControl& webCache = conSvcH.webCacheControl();
   for (const auto& physcon : physcons) {
      const auto& refreshList = m_frontierRefresh.value();
      if (std::find(refreshList.begin(), refreshList.end(), physcon) == refreshList.end()
          && std::find(refreshList.begin(), refreshList.end(), conn) == refreshList.end()) {
         // set that a table DUMMYTABLE should be refreshed - indicates that everything
         // else in the schema should not be
         webCache.refreshTable(physcon, "DUMMYTABLE");
      } else {
         // set the schema to be refreshed
         webCache.refreshSchemaInfo(physcon);
      }
      ATH_MSG_DEBUG("Cache flag for connection " << physcon << " set to " << webCache.webCacheInfo(physcon).isSchemaInfoCached());
   }
   return(StatusCode::SUCCESS);
}

setObjPtr()

void PoolSvc::setObjPtr ( void *& obj, const Token * token )

overridevirtual

Returns

void

Parameters

obj	[OUT] pointer to the Data Object.
token	[IN] token of the Data Object for which a Pool Ref is filled.

Definition at line 300 of file PoolSvc.cxx.

                                                      {
   unsigned int contextId = IPoolSvc::kInputStream;
   const std::string& auxString = token->auxString();
   if (!auxString.empty()) {
      if (auxString.compare(0, 6, "[CTXT=") == 0) {
         ::sscanf(auxString.c_str(), "[CTXT=%08X]", &contextId);
      } else if (auxString.compare(0, 8, "[CLABEL=") == 0) {
         contextId = this->getInputContext(auxString);
      }
      if (contextId >= m_persistencySvcVec.size()) {
         ATH_MSG_WARNING("setObjPtr: Using default input Stream instead of id = " << contextId);
         contextId = IPoolSvc::kInputStream;
      }
   }
   ATH_MSG_VERBOSE("setObjPtr: token=" << token->toString() << ", auxString=" << auxString << ", contextID=" << contextId);
   // Get Context ID/label from Token
   std::lock_guard<CallMutex> lock(*m_pers_mut[contextId]);
   obj = m_persistencySvcVec[contextId]->readObject(*token, obj);
   std::map<unsigned int, unsigned int>::const_iterator maxFileIter = m_contextMaxFile.find(contextId);
   if (maxFileIter != m_contextMaxFile.end() && maxFileIter->second > 0) {
      m_guidLists[contextId].remove(token->dbID());
      m_guidLists[contextId].push_back(token->dbID());
      while (m_guidLists[contextId].size() > maxFileIter->second) {
         this->disconnectDb("FID:" + m_guidLists[contextId].begin()->toString(), contextId).ignore();
      }
   }
}

setShareMode()

void PoolSvc::setShareMode ( bool shareCat )

overridevirtual

Returns

void

Parameters

shareCat

[IN] bool to share the file catalog.

Definition at line 402 of file PoolSvc.cxx.

                                        {
   m_shareCat = shareCat;
}

setupPersistencySvc()

StatusCode PoolSvc::setupPersistencySvc ( )

private

Definition at line 175 of file PoolSvc.cxx.

                                        {
   clearState();
   ATH_MSG_INFO("Setting up APR FileCatalog and Streams");
   m_catalog = createCatalog();
   if (m_catalog != nullptr) {
      m_catalog->start();
   } else {
      ATH_MSG_FATAL("Failed to setup POOL File Catalog.");
      return(StatusCode::FAILURE);
   }
   // Setup a persistency services
   m_persistencySvcVec.push_back(pool::IPersistencySvc::create(*m_catalog).release()); // Read Service
   m_pers_mut.push_back(new CallMutex);
   if (!m_persistencySvcVec[IPoolSvc::kInputStream]->session().technologySpecificAttributes(pool::ROOT_StorageType.type()).setAttribute<bool>("ENABLE_THREADSAFETY", true)) {
      ATH_MSG_FATAL("Failed to enable thread safety in ROOT via PersistencySvc.");
      return(StatusCode::FAILURE);
   }
   m_contextMaxFile.insert(std::pair<unsigned int, int>(IPoolSvc::kInputStream, m_dbAgeLimit));
   if (!connect(pool::ITransaction::READ, IPoolSvc::kInputStream).isSuccess()) {
      ATH_MSG_FATAL("Failed to connect Input PersistencySvc.");
      return(StatusCode::FAILURE);
   }
   m_persistencySvcVec.push_back(pool::IPersistencySvc::create(*m_catalog).release()); // Write Service
   m_pers_mut.push_back(new CallMutex);
   pool::DatabaseConnectionPolicy policy;
   policy.setWriteModeForNonExisting(pool::DatabaseConnectionPolicy::CREATE);
   policy.setWriteModeForExisting(pool::DatabaseConnectionPolicy::OVERWRITE);
   if (m_fileOpen.value() == "update") {
      policy.setWriteModeForExisting(pool::DatabaseConnectionPolicy::UPDATE);
   }
   m_persistencySvcVec[IPoolSvc::kOutputStream]->session().setDefaultConnectionPolicy(policy);
   if (!m_persistencySvcVec[IPoolSvc::kOutputStream]->session().technologySpecificAttributes(pool::ROOT_StorageType.type()).setAttribute<int>("DEFAULT_CONTAINER_TYPE", pool::DbType::getType(m_defaultROOTContainerType).type())) {
      ATH_MSG_FATAL("Failed to set ROOT default container type via PersistencySvc.");
      return(StatusCode::FAILURE);
   }
 
   return(StatusCode::SUCCESS);
}

start()

StatusCode PoolSvc::start ( )

overridevirtual

Required of all Gaudi services:

Definition at line 214 of file PoolSvc.cxx.

                          {
   // Switiching on ROOT implicit multi threading for AthenaMT
   if (m_useROOTIMT && Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1) {
      if (!m_persistencySvcVec[IPoolSvc::kInputStream]->session().technologySpecificAttributes(pool::ROOT_StorageType.type()).setAttribute<int>("ENABLE_IMPLICITMT", Gaudi::Concurrency::ConcurrencyFlags::numThreads() - 1)) {
         ATH_MSG_FATAL("Failed to enable implicit multithreading in ROOT via PersistencySvc.");
         return(StatusCode::FAILURE);
      }
      ATH_MSG_INFO("Enabled implicit multithreading in ROOT via PersistencySvc to: " << Gaudi::Concurrency::ConcurrencyFlags::numThreads() - 1);
   }
   return(StatusCode::SUCCESS);
}

stop()

StatusCode PoolSvc::stop ( )

overridevirtual

Definition at line 226 of file PoolSvc.cxx.

                         {
   ATH_MSG_VERBOSE("stop()");
   bool retError = false;
   for (unsigned int contextId = 0, imax = m_persistencySvcVec.size(); contextId < imax; contextId++) {
      if (!disconnect(contextId).isSuccess()) {
         ATH_MSG_FATAL("Cannot disconnect Stream: " << contextId);
         retError = true;
      }
   }
   return(retError ? StatusCode::FAILURE : StatusCode::SUCCESS);
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::map<unsigned int, std::list<Guid> > m_guidLists PoolSvc::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 234 of file PoolSvc.h.

m_attemptCatalogPatch

Gaudi::Property<bool> PoolSvc::m_attemptCatalogPatch {this,"AttemptCatalogPatch",true}

private

AttemptCatalogPatch, option to create catalog: default = false.

Definition at line 253 of file PoolSvc.h.

{this,"AttemptCatalogPatch",true};

m_catalog

pool::IFileCatalog* PoolSvc::m_catalog {nullptr}

private

Definition at line 226 of file PoolSvc.h.

{nullptr};

m_connClean

Gaudi::Property<bool> PoolSvc::m_connClean {this,"ConnectionCleanUp",false}

private

ConnectionCleanUp - whether to use CORAL connection management thread: default = false.

Definition at line 261 of file PoolSvc.h.

{this,"ConnectionCleanUp",false};

m_context

coral::Context* PoolSvc::m_context {nullptr}

private

Definition at line 224 of file PoolSvc.h.

{nullptr};

m_contextMaxFile

std::map<unsigned int, unsigned int> PoolSvc::m_contextMaxFile

private

Definition at line 232 of file PoolSvc.h.

m_dbAgeLimit

Gaudi::Property<int> PoolSvc::m_dbAgeLimit {this,"MaxFilesOpen",0}

private

MaxFilesOpen, option to have PoolSvc limit the number of open Input Files: default = 0 (No files are closed automatically)

Definition at line 241 of file PoolSvc.h.

{this,"MaxFilesOpen",0};

m_defaultROOTContainerType

Gaudi::Property<std::string> PoolSvc::m_defaultROOTContainerType {this, "DefaultContainerType", "ROOTTREEINDEX"}

private

Default ROOT container type.

Definition at line 268 of file PoolSvc.h.

{this, "DefaultContainerType", "ROOTTREEINDEX"};

m_fileOpen

Gaudi::Property<std::string> PoolSvc::m_fileOpen {this,"FileOpen","overwrite"}

private

FileOpen, the open mode for the file ("append" or "overwrite").

Definition at line 238 of file PoolSvc.h.

{this,"FileOpen","overwrite"};

m_frontierComp

Gaudi::Property<int> PoolSvc::m_frontierComp {this,"FrontierCompression",5}

private

Frontier proprties, compression level and list of schemas to be refreshed: default = 5.

Definition at line 263 of file PoolSvc.h.

{this,"FrontierCompression",5};

m_frontierRefresh

Gaudi::Property<std::vector<std::string> > PoolSvc::m_frontierRefresh {this,"FrontierRefreshSchema",{}}

private

Definition at line 264 of file PoolSvc.h.

{this,"FrontierRefreshSchema",{}};

m_inputContextLabel

std::map<std::string, unsigned int> PoolSvc::m_inputContextLabel

private

Definition at line 229 of file PoolSvc.h.

m_mainOutputLabel

std::string PoolSvc::m_mainOutputLabel {}

private

Definition at line 231 of file PoolSvc.h.

{};

m_outputContextLabel

std::map<std::string, unsigned int> PoolSvc::m_outputContextLabel

private

Definition at line 230 of file PoolSvc.h.

m_pers_mut

std::vector<CallMutex*> PoolSvc::m_pers_mut

private

Definition at line 228 of file PoolSvc.h.

m_persistencySvcVec

std::vector<pool::IPersistencySvc*> PoolSvc::m_persistencySvcVec

private

Definition at line 227 of file PoolSvc.h.

m_pool_mut

CallMutex PoolSvc::m_pool_mut

mutableprivate

Definition at line 223 of file PoolSvc.h.

m_readCatalog

Gaudi::Property<std::vector<std::string> > PoolSvc::m_readCatalog {this,"ReadCatalog",{},"List of catalog files to read from","OrderedSet<std::string>"}

private

ReadCatalog, the list of additional POOL input file catalogs to consult: default = empty vector.

Definition at line 246 of file PoolSvc.h.

{this,"ReadCatalog",{},"List of catalog files to read from","OrderedSet<std::string>"};

m_retrialPeriod

Gaudi::Property<int> PoolSvc::m_retrialPeriod {this,"ConnectionRetrialPeriod",300}

private

ConnectionRetrialPeriod, retry period for CORAL Connection Service: default = 30 seconds.

Definition at line 255 of file PoolSvc.h.

{this,"ConnectionRetrialPeriod",300};

m_retrialTimeOut

Gaudi::Property<int> PoolSvc::m_retrialTimeOut {this,"ConnectionRetrialTimeOut",3600}

private

ConnectionRetrialTimeOut, the retrial time out for CORAL Connection Service: default = 300 seconds.

Definition at line 257 of file PoolSvc.h.

{this,"ConnectionRetrialTimeOut",3600};

m_shareCat

bool PoolSvc::m_shareCat {false}

private

Definition at line 225 of file PoolSvc.h.

{false};

m_sortReplicas

Gaudi::Property<bool> PoolSvc::m_sortReplicas {this,"SortReplicas",true}

private

Use DBReplicaSvc to sort database connections, default = true.

Definition at line 266 of file PoolSvc.h.

{this,"SortReplicas",true};

m_timeOut

Gaudi::Property<int> PoolSvc::m_timeOut {this,"ConnectionTimeOut",5}

private

ConnectionTimeOut, the time out for CORAL Connection Service: default = 5 seconds.

Definition at line 259 of file PoolSvc.h.

{this,"ConnectionTimeOut",5};

m_useROOTIMT

Gaudi::Property<bool> PoolSvc::m_useROOTIMT {this,"UseROOTImplicitMT",true}

private

Use ROOT Implicit MultiThreading, default = true.

Definition at line 248 of file PoolSvc.h.

{this,"UseROOTImplicitMT",true};

m_useROOTMaxTree

Gaudi::Property<bool> PoolSvc::m_useROOTMaxTree {this,"UseROOTIncreaseVMaxTree",false}

private

Increase virtual TTree size to avoid backreads in multithreading, default = false.

Definition at line 250 of file PoolSvc.h.

{this,"UseROOTIncreaseVMaxTree",false};

m_writeCatalog

Gaudi::Property<std::string> PoolSvc::m_writeCatalog {this,"WriteCatalog","xmlcatalog_file:PoolFileCatalog.xml"}

private

WriteCatalog, the file catalog to be used to register output files (also default input catalog): default = "" (use POOL default).

Definition at line 244 of file PoolSvc.h.

{this,"WriteCatalog","xmlcatalog_file:PoolFileCatalog.xml"};

---

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

• PoolSvc.h
• PoolSvc.cxx