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: More...
virtual StatusCode	io_reinit () override
virtual StatusCode	start () override
	Required of all Gaudi services: More...
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
	Required of all Gaudi services: More...
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 const std::map< std::string, unsigned int > &	getInputContextMap () 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). More...
virtual StatusCode	commit (unsigned int contextId=IPoolSvc::kInputStream) const override
	Commit data for a given contextId and flush buffer. More...
virtual StatusCode	commitAndHold (unsigned int contextId=IPoolSvc::kInputStream) const override
	Commit data for a given contextId and hold buffer. More...
virtual StatusCode	disconnect (unsigned int contextId=IPoolSvc::kInputStream) const override
	Disconnect PersistencySvc associated with a contextId. More...
virtual StatusCode	disconnectDb (const std::string &connection, unsigned int contextId=IPoolSvc::kInputStream) const override
	Disconnect single Database. More...
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. More...
virtual StatusCode	getAttribute (const std::string &optName, std::string &data, long tech, unsigned int contextId=IPoolSvc::kInputStream) const override
	Get POOL attributes - domain. More...
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. More...
virtual StatusCode	setAttribute (const std::string &optName, const std::string &data, long tech, unsigned int contextId=IPoolSvc::kOutputStream) const override
	Set POOL attributes - domain. More...
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. More...
virtual StatusCode	setFrontierCache (const std::string &conn) override
	Setup Frontier cache for given logical or physical connection name. More...
virtual	~PoolSvc ()
	Destructor. More...

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. More...
std::unique_ptr< pool::IContainer >	getContainerHandle (pool::IDatabase *dbH, const std::string &contName) const
	Get Container handle. More...
std::string	poolCondPath (const std::string &leaf)
	Resolve a file using ATLAS_POOLCOND_PATH. More...

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
StringProperty	m_fileOpen {this,"FileOpen","overwrite"}
	FileOpen, the open mode for the file ("append" or "overwrite"). More...
IntegerProperty	m_dbAgeLimit {this,"MaxFilesOpen",0}
	MaxFilesOpen, option to have PoolSvc limit the number of open Input Files: default = 0 (No files are closed automatically) More...
StringProperty	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). More...
StringArrayProperty	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. More...
BooleanProperty	m_useROOTIMT {this,"UseROOTImplicitMT",true}
	Use ROOT Implicit MultiThreading, default = true. More...
BooleanProperty	m_useROOTMaxTree {this,"UseROOTIncreaseVMaxTree",false}
	Increase virtual TTree size to avoid backreads in multithreading, default = false. More...
BooleanProperty	m_attemptCatalogPatch {this,"AttemptCatalogPatch",true}
	AttemptCatalogPatch, option to create catalog: default = false. More...
IntegerProperty	m_retrialPeriod {this,"ConnectionRetrialPeriod",300}
	ConnectionRetrialPeriod, retry period for CORAL Connection Service: default = 30 seconds. More...
IntegerProperty	m_retrialTimeOut {this,"ConnectionRetrialTimeOut",3600}
	ConnectionRetrialTimeOut, the retrial time out for CORAL Connection Service: default = 300 seconds. More...
IntegerProperty	m_timeOut {this,"ConnectionTimeOut",5}
	ConnectionTimeOut, the time out for CORAL Connection Service: default = 5 seconds. More...
BooleanProperty	m_connClean {this,"ConnectionCleanUp",false}
	ConnectionCleanUp - whether to use CORAL connection management thread: default = false. More...
IntegerProperty	m_frontierComp {this,"FrontierCompression",5}
	Frontier proprties, compression level and list of schemas to be refreshed: default = 5. More...
StringArrayProperty	m_frontierRefresh {this,"FrontierRefreshSchema",{}}
BooleanProperty	m_sortReplicas {this,"SortReplicas",true}
	Use DBReplicaSvc to sort database connections, default = true. More...
StringProperty	m_defaultROOTContainerType {this, "DefaultContainerType", "ROOTTREEINDEX"}
	Default ROOT container type. More...

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 205 of file PoolSvc.h.

Constructor & Destructor Documentation

~PoolSvc()

PoolSvc::~PoolSvc ( )

virtual

Destructor.

Definition at line 982 of file PoolSvc.cxx.

                  {
}

Member Function Documentation

catalog()

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

overridevirtual

Returns

the file catalog.

Definition at line 401 of file PoolSvc.cxx.

                                               {
   return(m_catalog);
}

clearState()

void PoolSvc::clearState ( )

private

Definition at line 240 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 622 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 640 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 590 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 389 of file PoolSvc.cxx.

                                           {
   return(m_context);
}

createCatalog()

pool::IFileCatalog * PoolSvc::createCatalog ( )

private

Definition at line 942 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 438 of file PoolSvc.cxx.

                                      {
   ATH_MSG_DEBUG("createCollection() type="<< collectionType << ", connection=" << connection
                 << ", name=" << collectionName << ", contextID=" << contextId);
   std::string collection(collectionName);
   if (collectionType == "RootCollection") {
      if (collectionName.find("PFN:") == std::string::npos
          && collectionName.find("LFN:") == std::string::npos
          && collectionName.find("FID:") == std::string::npos) {
     collection = "PFN:" + collectionName;
      }
   }
   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.");
      }
   }
   // Check whether Collection Container exists.
   if (collectionType == "ImplicitCollection") {
      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();
            }
         }
         std::unique_ptr<pool::IContainer> contH = getContainerHandle(dbH.get(), collection);
         if (contH == nullptr) {
            ATH_MSG_INFO("Failed to find container " << collection << " to create POOL collection.");
            if (insertFile && m_attemptCatalogPatch.value()) {
               patchCatalog(connection.substr(4), *dbH);
             }
            return(nullptr); // no events
         }
      } catch(std::exception& e) {
         ATH_MSG_INFO("Failed to open container to check POOL collection - trying.");
      }
   }
 
   // access to these variables is locked below:
   pool::CollectionFactory* collFac ATLAS_THREAD_SAFE = pool::CollectionFactory::get();
   pool::ICollection* collPtr ATLAS_THREAD_SAFE = nullptr;
 
   pool::CollectionDescription collDes(collection, collectionType, collectionType == "ImplicitCollection" ? connection : "");
   if (collectionType == "RootCollection" &&
       m_persistencySvcVec[contextId]->session().defaultConnectionPolicy().writeModeForNonExisting() != pool::DatabaseConnectionPolicy::RAISE_ERROR) {
      ATH_MSG_INFO("Writing RootCollection - do not pass session pointer");
      std::scoped_lock lock(m_pool_mut);
      collPtr = collFac->create(collDes,  pool::ICollection::READ);
   } else {
      // Try to open APR EventTags Collection in the input file - first as RootCollection, then as RNTCollection
      std::scoped_lock lock(m_pool_mut);
      std::string       tree_error, rntuple_error;
      try {
         collPtr = collFac->create(collDes, pool::ICollection::READ, &m_persistencySvcVec[contextId]->session());
      } catch (std::exception &e) {
         tree_error = e.what();
      }
      if( !collPtr ) try {
         collDes.setType("RNTCollection");
         collPtr = collFac->create(collDes, pool::ICollection::READ, &m_persistencySvcVec[contextId]->session());
      } catch (std::exception &e) {
         if (insertFile) {
            std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
            if (dbH != nullptr) {
               if (!dbH->fid().empty()) {
                  return(nullptr); // no events
               }
            }
         }
         rntuple_error = e.what();
      }
      if( !collPtr ) throw std::runtime_error( "Failed to open APR Collection as RootCollection or RNTCollection: "
                                            + tree_error + " | " + rntuple_error + "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 655 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 677 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 260 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 736 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 713 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 1012 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 985 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 695 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 360 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()

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

overridevirtual

Returns

map of all labelled input contexts.

Definition at line 385 of file PoolSvc.cxx.

                                                                         {
   return(m_inputContextLabel);
}

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 329 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 566 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 58 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 265 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 135 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 393 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 405 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::null().toString().size()) { // 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 558 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 1029 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 277 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 423 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 811 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 787 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 883 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 301 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 397 of file PoolSvc.cxx.

                                        {
   m_shareCat = shareCat;
}

setupPersistencySvc()

StatusCode PoolSvc::setupPersistencySvc ( )

private

Definition at line 176 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 215 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 227 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 230 of file PoolSvc.h.

m_attemptCatalogPatch

BooleanProperty PoolSvc::m_attemptCatalogPatch {this,"AttemptCatalogPatch",true}

private

AttemptCatalogPatch, option to create catalog: default = false.

Definition at line 249 of file PoolSvc.h.

m_catalog

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

private

Definition at line 222 of file PoolSvc.h.

m_connClean

BooleanProperty PoolSvc::m_connClean {this,"ConnectionCleanUp",false}

private

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

Definition at line 257 of file PoolSvc.h.

m_context

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

private

Definition at line 220 of file PoolSvc.h.

m_contextMaxFile

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

private

Definition at line 228 of file PoolSvc.h.

m_dbAgeLimit

IntegerProperty 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 237 of file PoolSvc.h.

m_defaultROOTContainerType

StringProperty PoolSvc::m_defaultROOTContainerType {this, "DefaultContainerType", "ROOTTREEINDEX"}

private

Default ROOT container type.

Definition at line 264 of file PoolSvc.h.

m_fileOpen

StringProperty PoolSvc::m_fileOpen {this,"FileOpen","overwrite"}

private

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

Definition at line 234 of file PoolSvc.h.

m_frontierComp

IntegerProperty PoolSvc::m_frontierComp {this,"FrontierCompression",5}

private

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

Definition at line 259 of file PoolSvc.h.

m_frontierRefresh

StringArrayProperty PoolSvc::m_frontierRefresh {this,"FrontierRefreshSchema",{}}

private

Definition at line 260 of file PoolSvc.h.

m_inputContextLabel

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

private

Definition at line 225 of file PoolSvc.h.

m_mainOutputLabel

std::string PoolSvc::m_mainOutputLabel {}

private

Definition at line 227 of file PoolSvc.h.

m_outputContextLabel

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

private

Definition at line 226 of file PoolSvc.h.

m_pers_mut

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

private

Definition at line 224 of file PoolSvc.h.

m_persistencySvcVec

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

private

Definition at line 223 of file PoolSvc.h.

m_pool_mut

CallMutex PoolSvc::m_pool_mut

mutableprivate

Definition at line 219 of file PoolSvc.h.

m_readCatalog

StringArrayProperty 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 242 of file PoolSvc.h.

m_retrialPeriod

IntegerProperty PoolSvc::m_retrialPeriod {this,"ConnectionRetrialPeriod",300}

private

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

Definition at line 251 of file PoolSvc.h.

m_retrialTimeOut

IntegerProperty PoolSvc::m_retrialTimeOut {this,"ConnectionRetrialTimeOut",3600}

private

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

Definition at line 253 of file PoolSvc.h.

m_shareCat

bool PoolSvc::m_shareCat {false}

private

Definition at line 221 of file PoolSvc.h.

m_sortReplicas

BooleanProperty PoolSvc::m_sortReplicas {this,"SortReplicas",true}

private

Use DBReplicaSvc to sort database connections, default = true.

Definition at line 262 of file PoolSvc.h.

m_timeOut

IntegerProperty PoolSvc::m_timeOut {this,"ConnectionTimeOut",5}

private

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

Definition at line 255 of file PoolSvc.h.

m_useROOTIMT

BooleanProperty PoolSvc::m_useROOTIMT {this,"UseROOTImplicitMT",true}

private

Use ROOT Implicit MultiThreading, default = true.

Definition at line 244 of file PoolSvc.h.

m_useROOTMaxTree

BooleanProperty PoolSvc::m_useROOTMaxTree {this,"UseROOTIncreaseVMaxTree",false}

private

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

Definition at line 246 of file PoolSvc.h.

m_writeCatalog

StringProperty 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 240 of file PoolSvc.h.

---

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

• PoolSvc.h
• PoolSvc.cxx