PoolSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef POOLSVC_H
#define POOLSVC_H
 
#include "PoolSvc/IPoolSvc.h"
#include "GaudiKernel/IIoComponent.h"
#include "AthenaBaseComps/AthService.h"
#include "CxxUtils/checker_macros.h"
#include "PersistentDataModel/Guid.h"
 
#include <string>
#include <vector>
#include <map>
#include <mutex>
#include <memory>
 
// Forward declarations
namespace pool {
   class IContainer;
   class IDatabase;
   class IPersistencySvc;
}
 
 
class PoolSvc : public extends<AthService, IPoolSvc, IIoComponent> {
 
public: // Non-static members
   virtual StatusCode initialize() override;
   virtual StatusCode io_reinit() override;
   virtual StatusCode start() override;
   virtual StatusCode stop() override;
   virtual StatusCode finalize() override;
   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;
 
   virtual
   StatusCode commit(unsigned int contextId = IPoolSvc::kInputStream) const override;
 
   virtual
   StatusCode commitAndHold(unsigned int contextId = IPoolSvc::kInputStream) const override;
 
   virtual
   StatusCode disconnect(unsigned int contextId = IPoolSvc::kInputStream) const override;
 
   virtual
   StatusCode disconnectDb(const std::string& connection,
       unsigned int contextId = IPoolSvc::kInputStream) const override;
 
   virtual
   long long int getFileSize(const std::string& dbName, long tech, unsigned int contextId) const override;
 
   virtual
   StatusCode getAttribute(const std::string& optName,
       std::string& data,
       long tech,
       unsigned int contextId = IPoolSvc::kInputStream) const override;
 
   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;
 
   virtual
   StatusCode setAttribute(const std::string& optName,
       const std::string& data,
       long tech,
       unsigned int contextId = IPoolSvc::kOutputStream) const override;
 
   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;
 
   virtual
   StatusCode setFrontierCache(const std::string& conn) override;
 
   using base_class::base_class;
 
   virtual ~PoolSvc();
 
private: // data
   typedef std::recursive_mutex CallMutex;
   // Lock Guard class to safely lock a mutex for a given contextId
   class ContextLock {
      std::unique_lock< CallMutex > m_lock;
   public:
      ContextLock(int contextId, CallMutex &glob_mtx, const std::vector<CallMutex*> &ctx_mutexes) {
         // lock the global mutex to gain exclusive access to the context mutexes vector
         std::lock_guard<CallMutex>    temp_lock( glob_mtx );
         // lock the mutex for the given context ID for the lifetime of this object
         m_lock = std::unique_lock< CallMutex >{ *ctx_mutexes[contextId] };
      }
      ~ContextLock() { m_lock.unlock(); }
   };
 
   mutable 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;
   // Cache for open file guids for each m_persistencySvcVec member, protected by m_pers_mut
   mutable std::map<unsigned int, std::list<Guid> >  m_guidLists ATLAS_THREAD_SAFE;
 
private: // properties
   Gaudi::Property<std::string> m_fileOpen{this,"FileOpen","overwrite"};
   Gaudi::Property<int> m_dbAgeLimit{this,"MaxFilesOpen",0};
   Gaudi::Property<std::string> m_writeCatalog{this,"WriteCatalog","xmlcatalog_file:PoolFileCatalog.xml"};
   Gaudi::Property<std::vector<std::string>> m_readCatalog{this,"ReadCatalog",{},"List of catalog files to read from","OrderedSet<std::string>"};
   Gaudi::Property<bool> m_useROOTIMT{this,"UseROOTImplicitMT",true};
   Gaudi::Property<bool> m_useROOTMaxTree{this,"UseROOTIncreaseVMaxTree",false};
 
   Gaudi::Property<bool> m_attemptCatalogPatch{this,"AttemptCatalogPatch",true};
   Gaudi::Property<int> m_retrialPeriod{this,"ConnectionRetrialPeriod",300};
   Gaudi::Property<int> m_retrialTimeOut{this,"ConnectionRetrialTimeOut",3600};
   Gaudi::Property<int> m_timeOut{this,"ConnectionTimeOut",5};
   Gaudi::Property<bool> m_connClean{this,"ConnectionCleanUp",false};
   Gaudi::Property<int> m_frontierComp{this,"FrontierCompression",5};
   Gaudi::Property<std::vector<std::string>> m_frontierRefresh{this,"FrontierRefreshSchema",{}};
   Gaudi::Property<bool> m_sortReplicas{this,"SortReplicas",true};
   Gaudi::Property<std::string> m_defaultROOTContainerType{this, "DefaultContainerType", "ROOTTREEINDEX"};
 
private: // internal helper functions
   // delete all APR::Persistency Services, Catalog, Mutexes and Indexes
   void clearState();
 
   pool::IFileCatalog* createCatalog();
   void patchCatalog(const std::string& pfn, pool::IDatabase& dbH) const;
 
   // setup APR persistency
   StatusCode setupPersistencySvc();
 
   std::unique_ptr<pool::IDatabase> getDbHandle(unsigned int contextId, const std::string& dbName) const;
   std::unique_ptr<pool::IContainer> getContainerHandle(pool::IDatabase* dbH, const std::string& contName) const;
 
   std::string poolCondPath(const std::string& leaf);
};
#endif