Manages the content of the metadata stores. More...

#include <MetaDataSvc.h>

Inheritance diagram for MetaDataSvc:

Classes
class	ToolLockGuard

Public Member Functions
	MetaDataSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor.
virtual	~MetaDataSvc ()
	Destructor.
virtual StatusCode	prepareOutput ()
	Makes the metadata store ready for output.
virtual void	handle (const Incident &incident) override
	react to file incidents.
StatusCode	transitionMetaDataFile (const std::string &outputConn, bool disconnect)
	Transition output metadata file - fire MeteDataStop incident to transition OutputStream and disconnect now if requested.
virtual StatusCode	io_reinit () override
	Implements IIoComponent interface sets m_outputPrepared to false and prints some information.
StatusCode	rootOpenAction (FILEMGR_CALLBACK_ARGS)
virtual StoreGateSvc *	outputDataStore () const override final
virtual const std::string	currentRangeID () const override final
CLID	remapMetaContCLID (const CLID &item_id) const
void	lockTools () const
void	unlockTools () const
void	recordHook (const std::type_info &) override
void	removeHook (const std::type_info &) override
std::string	removeStreamFromKey (std::string &key)
	check if the metadata object key contains Stream name (added by SharedWriter in MetaDataSvc) remove stream part from the key (i.e.
virtual std::set< std::string >	getPerStreamKeysFor (const std::string &key) const override final
	Get all per-stream Key variants created for in-file metadata object with original key If no stream-specific keys are found, it returns the original key.

virtual StatusCode	initialize () override
	initialize the metadata service at the beginning of the job
virtual StatusCode	stop () override
	stop the metadata service
virtual StatusCode	finalize () override
	finalize the metadata service at the end of the job

virtual StatusCode	newMetadataSource (const Incident &)
	Fills the input metadata store with the content of the new input file.
virtual StatusCode	retireMetadataSource (const Incident &)
	Allows metadata tools to act before an input file is closed.

virtual StatusCode	prepareOutput (const std::string &outputName)
	Makes the metadata store ready for output with SharedWriter Calls the metaDataStop method of all MetaDataTool interfaces in m_metaDataTool.
virtual StatusCode	shmProxy (const std::string &filename) override
	Loads file metadata from memory shared between streams in SharedWriter This function clears the input and output metadata stores.

StatusCode	preLoadAddresses (StoreID::type, IAddressProvider::tadList &) override
	does nothing.
StatusCode	loadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
	loads addresses of versioned metadata object.
StatusCode	updateAddress (StoreID::type, SG::TransientAddress *, const EventContext &) override
	always fails

Private Member Functions
StatusCode	addProxyToInputMetaDataStore (const std::string &tokenStr)
StatusCode	initInputMetaDataStore (const std::string &fileName)
	Initialize input metadata store - can be called directly or via BeginInputFile incident.

Private Attributes
ServiceHandle< StoreGateSvc >	m_inputDataStore
ServiceHandle< StoreGateSvc >	m_outputDataStore
ServiceHandle< IAddressCreator >	m_addrCrtr { this, "ConversionService", "AthenaPoolCnvSvc" }
ServiceHandle< IFileMgr >	m_fileMgr
ServiceHandle< IIncidentSvc >	m_incSvc
ServiceHandle< OutputStreamSequencerSvc >	m_outSeqSvc
ServiceHandle< IClassIDSvc >	m_classIDSvc {"ClassIDSvc", name()}
long	m_storageType {0L}
bool	m_clearedInputDataStore {true}
bool	m_clearedOutputDataStore {false}
bool	m_allowMetaDataStop {false}
bool	m_beginInputFileSeen {false}
bool	m_outputPrepared {false}
std::map< std::string_view, CLID >	m_persToClid {}
std::set< CLID >	m_handledClasses {}
std::map< std::string, std::set< std::string > >	m_streamKeys {}
Gaudi::Property< std::string >	m_metaDataCont {this, "MetaDataContainer", ""}
	MetaDataContainer, POOL container name for MetaData.
PublicToolHandleArray< IMetaDataTool >	m_metaDataTools {this, "MetaDataTools", {}}
	MetaDataTools, vector with the MetaData tools.

Static Private Attributes
static constexpr std::string_view	m_streamInKeyMark {"__STREAM["}
	marker string for embedding stream name in MetaData object keys for SharedWriter server

Detailed Description

Manages the content of the metadata stores.

This service orchestrates the reading of metadata from input files and its propagation to the output with the help of the IMetaDataTool interfaces in m_metaDataTools. The MetaDataSvc reacts to BeginInputFile and EndInputFile incidents. It relies on the AthenaPoolCnvSvc (or whatever persistency service) to call the the appropriate prepareOutput method when committing the MetaDataStore content to the output file.

On BeginInputFile it clears the InputMetaDataStore and populates it with content from the new input file. The beginInputFile methods of all tools are called to allow required actions on the metadata objects.

On EndInputFile the MetaDataSvc calls the endInputFile methods of all the interfaces in m_metaDataTools .

In jobs with multiple parallel output streams (SharedWriter) the metadata content from multiple streams is put into the output MetaDataStore. To do this the The MetaDataSvc accesses the memory shared with the output streams, and adds the content of their MetaDataStore to the shared InputMetaDataStore. This is done by the client calling shmProxy for each object to be added to the MetaDataStore. Afterwards the client must also fire BeginInputFile and EndInputFile incidents to allow the MetaDataTools to move their objects from the InputMetaDataStore to the MetaDataStore taking care of possible merges.

Example configuration:

ca = ComponentAccumulator()
ca.addService(CompFactory.StoreGateSvc("MetaDataStore"))
ca.addService(CompFactory.StoreGateSvc("InputMetaDataStore"))
metaDataSvc = CompFactory.MetaDataSvc("MetaDataSvc")
ca.addService(
    CompFactory.ProxyProviderSvc(ProviderNames=["MetaDataSvc"]))
metaDataSvc.MetaDataTools += [someMetaDataTool]

See also: IMetaDataTool; AthenaPoolCnvSvc

Definition at line 84 of file MetaDataSvc.h.

Constructor & Destructor Documentation

◆ MetaDataSvc()

MetaDataSvc::MetaDataSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Service Constructor.

Definition at line 54 of file MetaDataSvc.cxx.

    : base_class( name, pSvcLocator )
    , m_inputDataStore( "StoreGateSvc/InputMetaDataStore", name )
    , m_outputDataStore( "StoreGateSvc/MetaDataStore", name )
    , m_fileMgr( "FileMgr", name )
    , m_incSvc( "IncidentSvc", name )
    , m_outSeqSvc( "OutputStreamSequencerSvc", name )
    , m_persToClid{ { "DataHeader_p5", 222376821 },
                    { "EventStreamInfo_p3", 167728019 },
                    { "ByteStreamMetadataContainer_p1", 1076128893 },
                    { "IOVMetaDataContainer_p1", 1316383046 },
                    { "xAOD::EventFormat_v1", 243004407 },
                    { "xAOD::CutBookkeeperContainer_v1", 1234982351 },
                    { "xAOD::CutBookkeeperAuxContainer_v1", 1147935274 },
                    { "xAOD::TriggerMenuContainer_v1", 1107011239 },
                    { "DataVector<xAOD::TriggerMenu_v1>", 1107011239 },
                    { "xAOD::TriggerMenuAuxContainer_v1", 1212409402 },
                    { "xAOD::TriggerMenuJsonContainer_v1", 1221262614 },
                    { "DataVector<xAOD::TriggerMenuJson_v1>", 1221262614 },
                    { "xAOD::TriggerMenuJsonAuxContainer_v1", 373045213 },
                    { "xAOD::LumiBlockRangeContainer_v1", 1115934851 },
                    { "DataVector<xAOD::LumiBlockRange_v1>", 1115934851 },
                    { "xAOD::LumiBlockRangeAuxContainer_v1", 1251061086 },
                    { "xAOD::FileMetaData_v1", 178309087 },
                    { "xAOD::FileMetaDataAuxInfo_v1", 73252552 },
                    { "xAOD::RingSetConfContainer_v1", 1157997427 },
                    { "DataVector<xAOD::RingSetConf_v1>", 1157997427 },
                    { "xAOD::RingSetConfAuxContainer_v1", 1307745126 },
                    { "xAOD::TruthMetaDataContainer_v1", 1188015687 },
                    { "DataVector<xAOD::TruthMetaData_v1>", 1188015687 },
                    { "xAOD::TruthMetaDataAuxContainer_v1", 1094306618 } } {}

◆ ~MetaDataSvc()

MetaDataSvc::~MetaDataSvc ( )

virtualdefault

Destructor.

Member Function Documentation

◆ addProxyToInputMetaDataStore()

StatusCode MetaDataSvc::addProxyToInputMetaDataStore ( const std::string & tokenStr )

private

Definition at line 420 of file MetaDataSvc.cxx.

                                                                              {
   std::string fileName = tokenStr.substr(tokenStr.find("[FILE=") + 6);
   leftString(fileName, ']');
   std::string className = tokenStr.substr(tokenStr.find("[PNAME=") + 7);
   leftString(className, ']');
   std::string contName = tokenStr.substr(tokenStr.find("[CONT=") + 6);
   leftString(contName,']');
   std::size_t pos1 = contName.find('(');
   std::string keyName = contName.substr(pos1 + 1, contName.size() - pos1 - 2);
   std::size_t pos2 = keyName.find('/');
   if (pos2 != std::string::npos) keyName = keyName.substr(pos2 + 1);
   std::string numName = tokenStr.substr(tokenStr.find("[NUM=") + 5);
   leftString(numName,']');
   unsigned long num = 0;
   std::istringstream iss(numName);
   iss >> num;
   CLID clid = m_persToClid[className];
 
   // make stream-unique keys for infile metadata objects
   // AthenaOutputStream will use this to distribute objects to the right stream (and restore the original key)
   if( clid == 178309087 ) {  // FileMetaData
      std::string newName = std::format("{}{}{}{}", keyName, m_streamInKeyMark, fileName, "]");
      ATH_MSG_DEBUG("Recording " << keyName << " as " << newName);
      m_streamKeys[keyName].insert(newName);
      keyName = std::move(newName);
   }
   if( clid == 73252552 ) {  // FileMetaDataAuxInfo
      std::string newName = std::format("{}{}{}]{}",
                                       keyName.substr(0, keyName.find(RootAuxDynIO::AUX_POSTFIX)),
                                       m_streamInKeyMark,
                                       fileName,
                                       RootAuxDynIO::AUX_POSTFIX);
      ATH_MSG_DEBUG("Recording " << keyName << " as " << newName);
      m_streamKeys[keyName].insert(newName);
      keyName = std::move(newName);
   }
   const std::string par[3] = { "SHM" , keyName , std::move(className) };
   const unsigned long ipar[2] = { num , 0 };
   IOpaqueAddress* opqAddr = nullptr;
   SG::DataProxy* dp = m_inputDataStore->proxy(clid, keyName);
   if (dp != nullptr) {
      ATH_MSG_DEBUG("Resetting duplicate proxy for: " << clid << "#" << keyName << " from file: " << fileName);
      dp->reset();
   }
   if (!m_addrCrtr->createAddress(m_storageType, clid, par, ipar, opqAddr).isSuccess()) {
      ATH_MSG_FATAL("addProxyToInputMetaDataStore: Cannot create address for " << tokenStr);
      return(StatusCode::FAILURE);
   }
   if (m_inputDataStore->recordAddress(keyName, opqAddr).isFailure()) {
      ATH_MSG_FATAL("addProxyToInputMetaDataStore: Cannot create proxy for " << tokenStr);
      return(StatusCode::FAILURE);
   }
   if (m_inputDataStore->accessData(clid, keyName) == nullptr) {
      ATH_MSG_FATAL("addProxyToInputMetaDataStore: Cannot access data for " << tokenStr);
      return(StatusCode::FAILURE);
   }
   if (keyName.find(RootAuxDynIO::AUX_POSTFIX) != std::string::npos
       && m_inputDataStore->symLink(clid, keyName, 187169987).isFailure()) {
      ATH_MSG_WARNING("addProxyToInputMetaDataStore: Cannot symlink to AuxStore for " << tokenStr);
   }
   return(StatusCode::SUCCESS);
}

◆ currentRangeID()

const std::string MetaDataSvc::currentRangeID ( ) const

finaloverridevirtual

Definition at line 552 of file MetaDataSvc.cxx.

{
   return m_outSeqSvc.isValid()? m_outSeqSvc->currentRangeID() : "";
}

◆ finalize()

StatusCode MetaDataSvc::finalize ( )

overridevirtual

finalize the metadata service at the end of the job

Definition at line 144 of file MetaDataSvc.cxx.

                                 {
   // Release IncidentService
   if (!m_incSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release IncidentService.");
   }
   // Release FileMgr
   if (!m_fileMgr.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release FileMgr.");
   }
   // Release AddressCreator
   if (!m_addrCrtr.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release AddressCreator.");
   }
   // Release OutputMetaDataStore
   if (!m_outputDataStore.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release OutputMetaDataStore.");
   }
   // Release InputMetaDataStore
   if (!m_inputDataStore.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release InputMetaDataStore.");
   }
   if (m_beginInputFileSeen && !m_allowMetaDataStop) {
      ATH_MSG_WARNING("EndInputFile was not received before finalize");
   }
   return(StatusCode::SUCCESS);
}

◆ getPerStreamKeysFor()

std::set< std::string > MetaDataSvc::getPerStreamKeysFor ( const std::string & key ) const

nodiscardfinaloverridevirtual

Get all per-stream Key variants created for in-file metadata object with original key If no stream-specific keys are found, it returns the original key.

Definition at line 412 of file MetaDataSvc.cxx.

                                                                                           {
    if (!m_streamKeys.contains(key)) {
        return {key};
    }
    return m_streamKeys.at(key);
}

◆ handle()

void MetaDataSvc::handle ( const Incident & incident )

overridevirtual

react to file incidents.

calls newMetadataSource on BeginInputFile and retireMetadataSource on EndInputFile. Does

Parameters

incident is expected to be BeginInputFile or EndInputFile

Definition at line 324 of file MetaDataSvc.cxx.

                                            {
   const FileIncident* fileInc  = dynamic_cast<const FileIncident*>(&inc);
   if (fileInc == nullptr) {
      ATH_MSG_ERROR("Unable to get FileName from EndInputFile incident");
      return;
   }
   const std::string fileName = fileInc->fileName();
   ATH_MSG_DEBUG("handle() " << inc.type() << " for " << fileName);
 
   if (inc.type() == "FirstInputFile") {
      // Register open/close callback actions
     using namespace boost::placeholders;
      Io::bfcn_action_t boa = boost::bind(&MetaDataSvc::rootOpenAction, this, _1,_2);
      if (m_fileMgr->regAction(std::move(boa), Io::OPEN).isFailure()) {
         ATH_MSG_FATAL("Cannot register ROOT file open action with FileMgr.");
      }
      if (!initInputMetaDataStore(fileName).isSuccess()) {
         ATH_MSG_WARNING("Unable to initialize InputMetaDataStore");
      }
   } else if (inc.type() == "BeginInputFile" || inc.type() == "BeginInputMemFile") {
      if(newMetadataSource(inc).isFailure()) {
         ATH_MSG_ERROR("Could not process new metadata source " << fileName);
      }
   } else if (inc.type() == "EndInputFile" || inc.type() == "EndInputMemFile") {
      if(retireMetadataSource(inc).isFailure()) {
         ATH_MSG_ERROR("Could not retire metadata source " << fileName);
      }
   }
}

◆ initialize()

StatusCode MetaDataSvc::initialize ( )

overridevirtual

initialize the metadata service at the beginning of the job

Definition at line 90 of file MetaDataSvc.cxx.

                                   {
   ATH_MSG_INFO("Initializing " << name());
 
   // Retrieve InputMetaDataStore
   ATH_CHECK( m_inputDataStore.retrieve() );
   // Retrieve OutputMetaDataStore
   ATH_CHECK( m_outputDataStore.retrieve() );
   // Retrieve AddressCreator
   ATH_CHECK( m_addrCrtr.retrieve() );
 
   AthCnvSvc* cnvSvc = dynamic_cast<AthCnvSvc*>(m_addrCrtr.operator->());
   if (cnvSvc) {
      m_storageType = cnvSvc->repSvcType();
   } else {
      ATH_MSG_WARNING("Cannot get ConversionSvc Interface.");
   }
   // Get FileMgr
   ATH_CHECK( m_fileMgr.retrieve() );
 
   // Set to be listener for end of event
   ATH_CHECK( m_incSvc.retrieve() );
 
   ATH_CHECK( m_metaDataTools.retrieve() );
   ATH_MSG_INFO("Found " << m_metaDataTools);
 
   m_incSvc->addListener(this, "FirstInputFile", 80, true);
   m_incSvc->addListener(this, "BeginInputFile", 80, true);
   m_incSvc->addListener(this, "EndInputFile", 10, true);
   m_incSvc->addListener(this, "BeginInputMemFile", 80, true);
   m_incSvc->addListener(this, "EndInputMemFile", 10, true);
 
   // Register this service for 'I/O' events
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", this->name());
   ATH_CHECK( iomgr.retrieve() );
   ATH_CHECK( iomgr->io_register(this) );
 
   ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc", name());
   if (!joSvc.retrieve().isSuccess()) {
      ATH_MSG_WARNING("Cannot get JobOptionsSvc.");
   } else {
      if (joSvc->has("EventSelector.InputCollections")) {
         // Get EventSelector to force in-time initialization and FirstInputFile incident
         ServiceHandle<IEvtSelector> evtsel("EventSelector", this->name());
         if (!evtsel.retrieve().isSuccess()) {
            ATH_MSG_WARNING("Cannot get EventSelector.");
         }
      }
   }
   // retrieve the output sequences service (EventService) if available
   m_outSeqSvc.retrieve().ignore();
 
   return(StatusCode::SUCCESS);
}

◆ initInputMetaDataStore()

StatusCode MetaDataSvc::initInputMetaDataStore ( const std::string & fileName )

private

Initialize input metadata store - can be called directly or via BeginInputFile incident.

Definition at line 483 of file MetaDataSvc.cxx.

                                                                        {
   ATH_MSG_DEBUG("initInputMetaDataStore: file name " << fileName);
   m_clearedInputDataStore = false;
   // Load proxies for InputMetaDataStore
   if (m_metaDataCont.value().empty()) {
      ATH_MSG_DEBUG("MetaDataSvc called without MetaDataContainer set.");
      return(StatusCode::SUCCESS);
   }
   if (fileName.starts_with( "BSF:")) {
      ATH_MSG_DEBUG("MetaDataSvc called for non ROOT file.");
   } else if (fileName.compare(0, 3, "SHM")==0) {
      ATH_MSG_DEBUG("MetaDataSvc called for shared memory.");
   } else {
      const std::string par[2] = {
         fileName,
         std::format("{}(DataHeader)", m_metaDataCont.value())
      };
      const std::string parOld[2] = {
         fileName,
         std::format("{}{}", m_metaDataCont.value(), "DataHeader")
      };
      for (int verNumber = 0; verNumber < 100; verNumber++) {
         SG::VersionedKey myVersKey(name(), verNumber);
         if (m_inputDataStore->contains<DataHeader>(myVersKey)) {
            ATH_MSG_DEBUG("initInputMetaDataStore: MetaData Store already contains DataHeader, key = " << myVersKey);
         } else {
            const unsigned long ipar[2] = { (unsigned long)verNumber , 0 };
            IOpaqueAddress* opqAddr = nullptr;
            if (!m_addrCrtr->createAddress(m_storageType, ClassID_traits<DataHeader>::ID(), par, ipar, opqAddr).isSuccess()) {
               if (!m_addrCrtr->createAddress(m_storageType, ClassID_traits<DataHeader>::ID(), parOld, ipar, opqAddr).isSuccess()) {
                  break;
               }
            }
            if (m_inputDataStore->recordAddress(myVersKey, opqAddr).isFailure()) {
               ATH_MSG_WARNING("initInputMetaDataStore: Cannot create proxy for DataHeader, key = " << myVersKey);
            }
         }
      }
      std::list<SG::TransientAddress*> tList;
      ATH_CHECK(loadAddresses(StoreID::METADATA_STORE, tList));
      for (SG::TransientAddress* tad : tList) {
         CLID clid = tad->clID();
          ATH_MSG_VERBOSE("initInputMetaDataStore: add proxy for clid = " << clid << ", key = " << tad->name());
         if (m_inputDataStore->contains(tad->clID(), tad->name())) {
            ATH_MSG_DEBUG("initInputMetaDataStore: MetaData Store already contains clid = " << clid << ", key = " << tad->name());
         } else {
            if (!m_inputDataStore->recordAddress(tad->name(), tad->address())) {
               ATH_MSG_ERROR("initInputMetaDataStore: Cannot create proxy for clid = " << clid << ", key = " << tad->name());
               return StatusCode::FAILURE;
            }
         }
 
         for (CLID tclid : tad->transientID()) {
           if (tclid != clid) {
             if (m_inputDataStore->symLink (clid, tad->name(), tclid).isFailure()) {
               ATH_MSG_WARNING("Cannot make autosymlink from " <<
                               clid << "/" << tad->name() << " to " << tclid);
             }
           }
         }
         delete tad;
      }
      tList.clear();
   }
   ATH_MSG_DEBUG("Loaded input meta data store proxies");
   return(StatusCode::SUCCESS);
}

◆ io_reinit()

StatusCode MetaDataSvc::io_reinit ( )

overridevirtual

Implements IIoComponent interface sets m_outputPrepared to false and prints some information.

Returns: SUCCESS

See also: IIoComponent

Definition at line 383 of file MetaDataSvc.cxx.

                                  {
   ATH_MSG_INFO("I/O reinitialization...");
   ATH_MSG_DEBUG("Dumping InputMetaDataStore: " << m_inputDataStore->dump());
   ATH_MSG_DEBUG("Dumping OutputMetaDataStore: " << m_outputDataStore->dump());
   for (const auto& tool : m_metaDataTools) {
      ATH_MSG_INFO("Attached MetaDataTool: " << tool->name());
   }
   m_outputPrepared = false;
   return(StatusCode::SUCCESS);
}

◆ loadAddresses()

StatusCode MetaDataSvc::loadAddresses	(	StoreID::type	storeID,
		IAddressProvider::tadList &	tads )

override

loads addresses of versioned metadata object.

loops over all versions of the DataHeader and adds addresses of objects from DataHeaderElements to the tads with a version corresponding to version number of the DataHeader that contained them.

See also: ObjectWithVersion; DataHeader

Parameters

storeID	[IN] the identity of the store
tads	[OUT] list of addresses to objects from versions keys

Returns: FAILURE the DataHeader could not be retrieved, else SUCCESS

Definition at line 181 of file MetaDataSvc.cxx.

                                                                                        {
   if (storeID != StoreID::METADATA_STORE) { // should this (also) run in the INPUT_METADATA_STORE?
      return(StatusCode::SUCCESS);
   }
   // Put Additional MetaData objects into Input MetaData Store using VersionedKey
   std::list<SG::ObjectWithVersion<DataHeader> > allVersions;
   StatusCode sc = m_inputDataStore->retrieveAllVersions(allVersions, name());
   if (!sc.isSuccess()) {
      ATH_MSG_WARNING("Could not retrieve all versions for DataHeader, will not read Metadata");
   } else {
      int verNumber = -1;
      for (SG::ObjectWithVersion<DataHeader>& obj : allVersions) {
         ++verNumber;
         const DataHeader* dataHeader = obj.dataObject.cptr();
         if (dataHeader == nullptr) {
            ATH_MSG_ERROR("Could not get DataHeader, will not read Metadata");
            return(StatusCode::FAILURE);
         }
         for (const DataHeaderElement& dhe : *dataHeader) {
            const CLID clid = dhe.getPrimaryClassID();
            if (clid != ClassID_traits<DataHeader>::ID()) {
               SG::VersionedKey myVersObjKey(dhe.getKey(), verNumber);
               std::string key = dhe.getKey();
               if (verNumber != 0) {
                  key = myVersObjKey;
               }
               tads.push_back(dhe.getAddress(m_storageType, key));
            }
         }
      }
   }
   return(StatusCode::SUCCESS);
}

◆ lockTools()

void MetaDataSvc::lockTools ( ) const

Definition at line 603 of file MetaDataSvc.cxx.

                                  {
   ATH_MSG_DEBUG("Locking metadata tools");
   for(auto& tool : m_metaDataTools ) {
      const ILockableTool *lockable = dynamic_cast<const ILockableTool*>( tool.get() );
      if( lockable ) lockable->lock_shared();
   }
}

◆ newMetadataSource()

StatusCode MetaDataSvc::newMetadataSource ( const Incident & inc )

virtual

Fills the input metadata store with the content of the new input file.

Once the GUID and name of the input file are determined from the incident this function blocks stopping the MetaDataSvc by setting m_allowMetaDataStop to false. Then attempts first to clear the input metadata store and prepare it for the metadata tools by calling initInputMetaDataStore. The loops over all MetaDataTool interfaces in m_metaDataTools and calls their beginInputFile implementations.

See also: initInputMetaDataStore(); m_metaDataTools

Parameters

inc	The BeginInputFile incident fired on opening a new file

Returns: FAILURE when inc is not a file incident, the input metadata store cannot be set up, or a MetaDataTool fails. Otherwise SUCCESS.

Definition at line 215 of file MetaDataSvc.cxx.

{
   const FileIncident* fileInc = dynamic_cast<const FileIncident*>(&inc);
   if (fileInc == nullptr) {
      ATH_MSG_ERROR("Unable to get FileName from EndInputFile incident");
      return StatusCode::FAILURE;
   }
   const std::string guid = fileInc->fileGuid();
   const std::string fileName = fileInc->fileName();
   m_allowMetaDataStop = false;
   m_beginInputFileSeen = true;
   if (!fileName.starts_with( "BSF:")) {
      // the input file is _not_ bytestream
      if (!m_clearedInputDataStore) {
         if (!m_inputDataStore->clearStore().isSuccess()) {
            ATH_MSG_WARNING("Unable to clear input MetaData Proxies");
         }
         m_clearedInputDataStore = true;
      }
      ATH_CHECK(initInputMetaDataStore(fileName));
   }
   StatusCode rc{StatusCode::SUCCESS};
   for (auto& tool : m_metaDataTools) {
      ATH_MSG_DEBUG(" calling beginInputFile on " << tool->name() << " for GUID \"" << guid << "\"");
      if (tool->beginInputFile(guid).isFailure()) {
         ATH_MSG_ERROR("Unable to call beginInputFile for " << tool->name());
         rc = StatusCode::FAILURE;
      }
   }
   return rc;
}

◆ outputDataStore()

virtual StoreGateSvc * MetaDataSvc::outputDataStore ( ) const

inlinefinaloverridevirtual

Definition at line 235 of file MetaDataSvc.h.

                                                               {
    return &*m_outputDataStore;
  }

◆ preLoadAddresses()

StatusCode MetaDataSvc::preLoadAddresses	(	StoreID::type	,
		IAddressProvider::tadList &	)

inlineoverride

does nothing.

Parameters

storeID	[IN] store ID, this function only preloads detector store addresses.
tads	[OUT] list of the transient addresses which were preloaded.

Returns: SUCCESS

Definition at line 184 of file MetaDataSvc.h.

                                                                   {
    return StatusCode::SUCCESS;
  }

◆ prepareOutput()

StatusCode MetaDataSvc::prepareOutput ( )

virtual

Makes the metadata store ready for output.

Calls the metaDataStop method of all MetaDataTool interfaces in m_metaDataTool. Then release the metadata tools. This implementation assumes SharedWriter is not being used.

Returns: SUCCESS unless a MetaDataTool fails, then FAILURE

Definition at line 264 of file MetaDataSvc.cxx.

{
   if (m_outputPrepared) {
      return StatusCode::SUCCESS;
   }
 
   StatusCode rc{StatusCode::SUCCESS};
   for (auto& tool : m_metaDataTools) {
      ATH_MSG_DEBUG(" calling metaDataStop for " << tool->name());
      if (tool->metaDataStop().isFailure()) {
         ATH_MSG_ERROR("Unable to call metaDataStop for " << tool->name());
         rc = StatusCode::FAILURE;
      }
   }
   if (!m_metaDataTools.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release " << m_metaDataTools);
   }
 
   m_outputPrepared = true;
   return rc;
}

◆ recordHook()

void MetaDataSvc::recordHook ( const std::type_info & typeInfo )

override

Definition at line 578 of file MetaDataSvc.cxx.

                                                         {
  const std::string& typeName = System::typeinfoName(typeInfo);
  ATH_MSG_VERBOSE("Handling record event of type " << typeName);
 
  CLID itemID = 0;
  if (m_classIDSvc->getIDOfTypeInfoName(typeName, itemID).isSuccess()) {
    auto result = m_handledClasses.insert(itemID);
    if (result.second)
      ATH_MSG_DEBUG("MetaDataSvc will handle " << typeName
                    << " ClassID: " << itemID);
  }
}

◆ remapMetaContCLID()

CLID MetaDataSvc::remapMetaContCLID ( const CLID & item_id ) const

Definition at line 558 of file MetaDataSvc.cxx.

{
   if (!m_handledClasses.contains(itemID)) {
      ATH_MSG_DEBUG("Not translating metadata item ID #" << itemID);
      return itemID;
   }
 
   std::string itemName;
   CLID contID = 0;
   if (m_classIDSvc->getTypeNameOfID(itemID, itemName).isSuccess()) {
     const std::string contName = std::format("MetaCont<{}>", itemName);
     ATH_MSG_DEBUG("Transforming " << contName << " to " << itemName
                   << " for output");
     if (m_classIDSvc->getIDOfTypeName(contName, contID).isSuccess())
       return contID;
   }
 
   return itemID;
}

◆ removeHook()

void MetaDataSvc::removeHook ( const std::type_info & typeInfo )

override

Definition at line 591 of file MetaDataSvc.cxx.

                                                         {
  const std::string& typeName = System::typeinfoName(typeInfo);
  ATH_MSG_VERBOSE("Handling removal event of type " << typeName);
 
  CLID itemID = 0;
  if (m_classIDSvc->getIDOfTypeInfoName(typeName, itemID).isSuccess()) {
    if (0 < m_handledClasses.erase(itemID))
      ATH_MSG_DEBUG("MetaDataSvc will no longer handle " << typeName
                    << " ClassID: " << itemID);
  }
}

◆ removeStreamFromKey()

std::string MetaDataSvc::removeStreamFromKey ( std::string & key )

check if the metadata object key contains Stream name (added by SharedWriter in MetaDataSvc) remove stream part from the key (i.e.

modify the parameter) and return it

Definition at line 400 of file MetaDataSvc.cxx.

                                                         {
   size_t pos = key.find(m_streamInKeyMark);
   if( pos==std::string::npos ) return "";
   size_t epos = key.find(']', pos);
   size_t spos = pos + m_streamInKeyMark.size();
   std::string stream = key.substr( spos, epos - spos );
   //cppcheck-suppress uselessCallsSubstr
   key = key.substr(0, pos) + key.substr(epos+1);
   return stream;
}

◆ retireMetadataSource()

StatusCode MetaDataSvc::retireMetadataSource ( const Incident & inc )

virtual

Allows metadata tools to act before an input file is closed.

Grabs the file GUID then calls the the endInputFile method of all metadata tools in m_metaDataTools providing the GUID as argument.

Parameters

inc	is a file incident fired before closing an input file

Returns: SUCCESS unless a MetaDataTool fails, then FAILURE

Definition at line 247 of file MetaDataSvc.cxx.

{
   const FileIncident* fileInc  = dynamic_cast<const FileIncident*>(&inc);
   if (fileInc == nullptr) {
      ATH_MSG_ERROR("Unable to get FileName from EndInputFile incident");
      return StatusCode::FAILURE;
   }
   const std::string guid = fileInc->fileGuid();
   ATH_MSG_DEBUG("retireMetadataSource: " << fileInc->fileName());
   for (auto& tool : m_metaDataTools) {
      ATH_MSG_DEBUG(" calling endInputFile on " << tool->name() << " for GUID \"" << guid << "\"");
      ATH_CHECK(tool->endInputFile(guid));
   }
   m_allowMetaDataStop = true;
   return StatusCode::SUCCESS;
}

◆ rootOpenAction()

StatusCode MetaDataSvc::rootOpenAction ( FILEMGR_CALLBACK_ARGS )

Definition at line 394 of file MetaDataSvc.cxx.

                                                            {
   return(StatusCode::SUCCESS);
}

◆ stop()

StatusCode MetaDataSvc::stop ( )

overridevirtual

stop the metadata service

Definition at line 172 of file MetaDataSvc.cxx.

                             {
   ATH_MSG_DEBUG("MetaDataSvc::stop()");
   // Fire metaDataStopIncident
   Incident metaDataStopIncident(name(), "MetaDataStop");
   m_incSvc->fireIncident(metaDataStopIncident);
   return(StatusCode::SUCCESS);
}

◆ transitionMetaDataFile()

StatusCode MetaDataSvc::transitionMetaDataFile	(	const std::string &	outputConn,
		bool	disconnect )

Transition output metadata file - fire MeteDataStop incident to transition OutputStream and disconnect now if requested.

Definition at line 356 of file MetaDataSvc.cxx.

{
   ATH_MSG_DEBUG("transitionMetaDataFile: " << outputConn );
 
   // this is normally called through EndInputFile inc, simulate it for EvSvc
   FileIncident inc("transitionMetaDataFile", "EndInputFile", "dummyMetaInputFileName", "");
   ATH_CHECK(retireMetadataSource(inc));
 
   // Reset flag to allow calling prepareOutput again at next transition
   m_outputPrepared = false;
 
   Incident metaDataStopIncident(name(), "MetaDataStop");
   m_incSvc->fireIncident(metaDataStopIncident);
 
   if( disconnect ) {
      AthCnvSvc* cnvSvc = dynamic_cast<AthCnvSvc*>(m_addrCrtr.operator->());
      if (cnvSvc) {
         if (!cnvSvc->disconnectOutput(outputConn).isSuccess()) {
            ATH_MSG_WARNING("Cannot get disconnect Output Files");
         }
      }
   }
 
   return(StatusCode::SUCCESS);
}

◆ unlockTools()

void MetaDataSvc::unlockTools ( ) const

Definition at line 611 of file MetaDataSvc.cxx.

                                    {
   ATH_MSG_DEBUG("Unlocking metadata tools");
   for(auto& tool : m_metaDataTools ) {
      const ILockableTool *lockable = dynamic_cast<const ILockableTool*>( tool.get() );
      if( lockable ) lockable->unlock_shared();
   }
}

◆ updateAddress()

StatusCode MetaDataSvc::updateAddress	(	StoreID::type	,
		SG::TransientAddress *	,
		const EventContext &	)

inlineoverride

always fails

Parameters

storeID	[IN] the identity of the store
tad	[IN] transient address to be updated
ctx	[IN] current event's context information

Returns: FAILURE

Definition at line 208 of file MetaDataSvc.h.

                                                           {
    return StatusCode::FAILURE;
  }

Member Data Documentation

◆ m_addrCrtr

ServiceHandle<IAddressCreator> MetaDataSvc::m_addrCrtr { this, "ConversionService", "AthenaPoolCnvSvc" }

private

Definition at line 300 of file MetaDataSvc.h.

300{ this, "ConversionService", "AthenaPoolCnvSvc" };

◆ m_allowMetaDataStop

bool MetaDataSvc::m_allowMetaDataStop {false}

private

Definition at line 309 of file MetaDataSvc.h.

309{false};

◆ m_beginInputFileSeen

bool MetaDataSvc::m_beginInputFileSeen {false}

private

Definition at line 310 of file MetaDataSvc.h.

310{false};

◆ m_classIDSvc

ServiceHandle<IClassIDSvc> MetaDataSvc::m_classIDSvc {"ClassIDSvc", name()}

private

Definition at line 304 of file MetaDataSvc.h.

304{"ClassIDSvc", name()};

◆ m_clearedInputDataStore

bool MetaDataSvc::m_clearedInputDataStore {true}

private

Definition at line 307 of file MetaDataSvc.h.

307{true};

◆ m_clearedOutputDataStore

bool MetaDataSvc::m_clearedOutputDataStore {false}

private

Definition at line 308 of file MetaDataSvc.h.

308{false};

◆ m_fileMgr

ServiceHandle<IFileMgr> MetaDataSvc::m_fileMgr

private

Definition at line 301 of file MetaDataSvc.h.

◆ m_handledClasses

std::set<CLID> MetaDataSvc::m_handledClasses {}

private

Definition at line 314 of file MetaDataSvc.h.

314{};

◆ m_incSvc

ServiceHandle<IIncidentSvc> MetaDataSvc::m_incSvc

private

Definition at line 302 of file MetaDataSvc.h.

◆ m_inputDataStore

ServiceHandle<StoreGateSvc> MetaDataSvc::m_inputDataStore

private

Definition at line 298 of file MetaDataSvc.h.

◆ m_metaDataCont

Gaudi::Property<std::string> MetaDataSvc::m_metaDataCont {this, "MetaDataContainer", ""}

private

MetaDataContainer, POOL container name for MetaData.

Definition at line 322 of file MetaDataSvc.h.

322{this, "MetaDataContainer", ""};

◆ m_metaDataTools

PublicToolHandleArray<IMetaDataTool> MetaDataSvc::m_metaDataTools {this, "MetaDataTools", {}}

private

MetaDataTools, vector with the MetaData tools.

Definition at line 324 of file MetaDataSvc.h.

324{this, "MetaDataTools", {}};

◆ m_outputDataStore

ServiceHandle<StoreGateSvc> MetaDataSvc::m_outputDataStore

private

Definition at line 299 of file MetaDataSvc.h.

◆ m_outputPrepared

bool MetaDataSvc::m_outputPrepared {false}

private

Definition at line 311 of file MetaDataSvc.h.

311{false};

◆ m_outSeqSvc

ServiceHandle<OutputStreamSequencerSvc> MetaDataSvc::m_outSeqSvc

private

Definition at line 303 of file MetaDataSvc.h.

◆ m_persToClid

std::map<std::string_view, CLID> MetaDataSvc::m_persToClid {}

private

Definition at line 312 of file MetaDataSvc.h.

312{};

◆ m_storageType

long MetaDataSvc::m_storageType {0L}

private

Definition at line 306 of file MetaDataSvc.h.

306{0L};

python.SystemOfUnits.L

float L

Definition SystemOfUnits.py:92

◆ m_streamInKeyMark

std::string_view MetaDataSvc::m_streamInKeyMark {"__STREAM["}

staticconstexprprivate

marker string for embedding stream name in MetaData object keys for SharedWriter server

Definition at line 316 of file MetaDataSvc.h.

316{"__STREAM["};

◆ m_streamKeys

std::map< std::string, std::set<std::string> > MetaDataSvc::m_streamKeys {}

private

Definition at line 318 of file MetaDataSvc.h.

318{};

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MetaDataSvc()

◆ ~MetaDataSvc()

Member Function Documentation

◆ addProxyToInputMetaDataStore()

◆ currentRangeID()

◆ finalize()

◆ getPerStreamKeysFor()

◆ handle()

◆ initialize()

◆ initInputMetaDataStore()

◆ io_reinit()

◆ loadAddresses()

◆ lockTools()

◆ newMetadataSource()

◆ outputDataStore()

◆ preLoadAddresses()

◆ prepareOutput()

◆ recordHook()

◆ remapMetaContCLID()

◆ removeHook()

◆ removeStreamFromKey()

◆ retireMetadataSource()

◆ rootOpenAction()

◆ stop()

◆ transitionMetaDataFile()

◆ unlockTools()

◆ updateAddress()

Member Data Documentation

◆ m_addrCrtr

◆ m_allowMetaDataStop

◆ m_beginInputFileSeen

◆ m_classIDSvc

◆ m_clearedInputDataStore

◆ m_clearedOutputDataStore

◆ m_fileMgr

◆ m_handledClasses

◆ m_incSvc

◆ m_inputDataStore

◆ m_metaDataCont

◆ m_metaDataTools

◆ m_outputDataStore

◆ m_outputPrepared

◆ m_outSeqSvc

◆ m_persToClid

◆ m_storageType

◆ m_streamInKeyMark

◆ m_streamKeys