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

#include <MetaDataSvc.h>

Inheritance diagram for MetaDataSvc:

Collaboration diagram for MetaDataSvc:

Classes
class	ToolLockGuard

Public Member Functions
	MetaDataSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor. More...

virtual	~MetaDataSvc ()
	Destructor. More...

virtual StatusCode	prepareOutput ()
	Makes the metadata store ready for output. More...

StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface) override
	Provide access to the interfaces implemented by this service. More...

virtual void	handle (const Incident &incident) override
	react to file incidents. More...

StatusCode	transitionMetaDataFile (const std::string &outputConn, bool disconnect)
	Transition output metadata file - fire MeteDataStop incident to transition OutputStream and disconnect now if requested. More...

virtual StatusCode	io_reinit () override
	Implements IIoComponent interface sets m_outputPrepared to false and prints some information. More...

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. More...

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. More...


virtual StatusCode	initialize () override
	initialize the metadata service at the beginning of the job More...

virtual StatusCode	stop () override
	stop the metadata service More...

virtual StatusCode	finalize () override
	finalize the metadata service at the end of the job More...


virtual StatusCode	newMetadataSource (const Incident &)
	Fills the input metadata store with the content of the new input file. More...

virtual StatusCode	retireMetadataSource (const Incident &)
	Allows metadata tools to act before an input file is closed. More...


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. More...

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. More...


StatusCode	preLoadAddresses (StoreID::type, IAddressProvider::tadList &) override
	does nothing. More...

StatusCode	loadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
	loads addresses of versioned metadata object. More...

StatusCode	updateAddress (StoreID::type, SG::TransientAddress *, const EventContext &) override
	always fails More...

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Retrieve interface ID. More...

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. More...

Private Attributes
ServiceHandle< StoreGateSvc >	m_inputDataStore

ServiceHandle< StoreGateSvc >	m_outputDataStore

ServiceHandle< IAddressCreator >	m_addrCrtr

ServiceHandle< IFileMgr >	m_fileMgr

ServiceHandle< IIncidentSvc >	m_incSvc

ServiceHandle< OutputStreamSequencerSvc >	m_outSeqSvc

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

long	m_storageType

bool	m_clearedInputDataStore

bool	m_clearedOutputDataStore

bool	m_allowMetaDataStop

bool	m_outputPrepared

std::map< std::string, CLID >	m_persToClid

std::map< CLID, std::string >	m_toolForClid

std::set< CLID >	m_handledClasses

const std::string	m_streamInKeyMark = "__STREAM["
	marker string for embedding stream name in MetaData object keys for SharedWriter server More...

std::map< std::string, std::set< std::string > >	m_streamKeys

StringProperty	m_metaDataCont
	MetaDataContainer, POOL container name for MetaData. More...

ToolHandleArray< IMetaDataTool >	m_metaDataTools
	MetaDataTools, vector with the MetaData tools. More...

Friends
class	SvcFactory< MetaDataSvc >

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 90 of file MetaDataSvc.h.

Constructor & Destructor Documentation

◆ MetaDataSvc()

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

Standard Service Constructor.

Definition at line 52 of file MetaDataSvc.cxx.

                                                                         : base_class(name, pSvcLocator),
     m_inputDataStore("StoreGateSvc/InputMetaDataStore", name),
     m_outputDataStore("StoreGateSvc/MetaDataStore", name),
     m_addrCrtr("AthenaPoolCnvSvc", name),
     m_fileMgr("FileMgr", name),
     m_incSvc("IncidentSvc", name),
         m_outSeqSvc("OutputStreamSequencerSvc", name),
     m_storageType(0L),
     m_clearedInputDataStore(true),
     m_clearedOutputDataStore(false),
     m_allowMetaDataStop(false),
         m_outputPrepared(false),
     m_persToClid(),
     m_toolForClid() {
    // declare properties
    declareProperty("MetaDataContainer", m_metaDataCont = "");
    declareProperty("MetaDataTools", m_metaDataTools);
    declareProperty("CnvSvc", m_addrCrtr = ServiceHandle<IAddressCreator>("AthenaPoolCnvSvc", name));
    // persistent class name to transient CLID map
    m_persToClid.insert(std::pair<std::string, CLID>("DataHeader_p5", 222376821));
    m_persToClid.insert(std::pair<std::string, CLID>("EventStreamInfo_p3", 167728019));
    m_persToClid.insert(std::pair<std::string, CLID>("ByteStreamMetadataContainer_p1", 1076128893));
    m_persToClid.insert(std::pair<std::string, CLID>("IOVMetaDataContainer_p1", 1316383046));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::EventFormat_v1", 243004407));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::CutBookkeeperContainer_v1", 1234982351));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::CutBookkeeperAuxContainer_v1", 1147935274));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::TriggerMenuContainer_v1", 1107011239));
    m_persToClid.insert(std::pair<std::string, CLID>("DataVector<xAOD::TriggerMenu_v1>", 1107011239));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::TriggerMenuAuxContainer_v1", 1212409402));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::TriggerMenuJsonContainer_v1", 1221262614));
    m_persToClid.insert(std::pair<std::string, CLID>("DataVector<xAOD::TriggerMenuJson_v1>", 1221262614));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::TriggerMenuJsonAuxContainer_v1", 373045213));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::LumiBlockRangeContainer_v1", 1115934851));
    m_persToClid.insert(std::pair<std::string, CLID>("DataVector<xAOD::LumiBlockRange_v1>", 1115934851));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::LumiBlockRangeAuxContainer_v1", 1251061086));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::FileMetaData_v1", 178309087));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::FileMetaDataAuxInfo_v1", 73252552));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::RingSetConfContainer_v1", 1157997427));
    m_persToClid.insert(std::pair<std::string, CLID>("DataVector<xAOD::RingSetConf_v1>", 1157997427));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::RingSetConfAuxContainer_v1", 1307745126));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::TruthMetaDataContainer_v1", 1188015687));
    m_persToClid.insert(std::pair<std::string, CLID>("DataVector<xAOD::TruthMetaData_v1>", 1188015687));
    m_persToClid.insert(std::pair<std::string, CLID>("xAOD::TruthMetaDataAuxContainer_v1", 1094306618));
    // some classes need to have new/different tools added for metadata propagation
    m_toolForClid.insert(std::pair<CLID, std::string>(167728019, "CopyEventStreamInfo"));
    m_toolForClid.insert(std::pair<CLID, std::string>(243004407, "xAODMaker::EventFormatMetaDataTool"));
    m_toolForClid.insert(std::pair<CLID, std::string>(1234982351, "BookkeeperTool"));
    m_toolForClid.insert(std::pair<CLID, std::string>(1107011239, "xAODMaker::TriggerMenuMetaDataTool"));
    m_toolForClid.insert(std::pair<CLID, std::string>(1221262614, "xAODMaker::TriggerMenuMetaDataTool"));
    m_toolForClid.insert(std::pair<CLID, std::string>(1115934851, "LumiBlockMetaDataTool"));
    m_toolForClid.insert(std::pair<CLID, std::string>(178309087, "xAODMaker::FileMetaDataTool"));
    m_toolForClid.insert(std::pair<CLID, std::string>(1188015687, "xAODMaker::TruthMetaDataTool"));
 }

◆ ~MetaDataSvc()

MetaDataSvc::~MetaDataSvc ( )

virtual

Destructor.

Definition at line 106 of file MetaDataSvc.cxx.

106 {

107 }

Member Function Documentation

◆ addProxyToInputMetaDataStore()

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

private

Definition at line 453 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];
    if (clid == 167728019) { // EventStreamInfo, will change tool to combine input metadata, clearing things before...
       bool foundTool = false;
       for (auto iter = m_metaDataTools.begin(), iterEnd = m_metaDataTools.end(); iter != iterEnd; iter++) {
          if ((*iter)->name() == "ToolSvc.CopyEventStreamInfo") foundTool = true;
       }
       if (!foundTool) {
          if (serviceLocator()->existsService("CutFlowSvc")) {
             ServiceHandle<IIncidentListener> cfSvc("CutFlowSvc", this->name()); // Disable CutFlowSvc by stopping its incidents.
             if (cfSvc.retrieve().isSuccess()) {
                ATH_MSG_INFO("Disabling incidents for: " << cfSvc.name());
                m_incSvc->removeListener(cfSvc.get(), IncidentType::BeginInputFile);
                m_incSvc->removeListener(cfSvc.get(), "MetaDataStop");
                cfSvc.release().ignore();
             }
          }
          if (serviceLocator()->existsService("xAODConfigSvc")) {
             ServiceHandle<IIncidentListener> xcSvc("xAODConfigSvc", this->name()); // Disable xAODConfigSvc, fails for merging
             if (xcSvc.retrieve().isSuccess()) {
                ATH_MSG_INFO("Disabling incidents for: " << xcSvc.name());
                m_incSvc->removeListener(xcSvc.get(), IncidentType::BeginInputFile);
                m_incSvc->removeListener(xcSvc.get(), IncidentType::BeginEvent);
                xcSvc.release().ignore();
             }
          }
       }
    }
    const std::string toolName = m_toolForClid[clid];
    if (!toolName.empty()) {
       std::string toolInstName;
       std::size_t pos = toolName.find("::");
       if (pos != std::string::npos) {
          toolInstName = toolName.substr(pos + 2);
       } else {
          toolInstName = toolName;
       }
       bool foundTool = false;
       for (auto iter = m_metaDataTools.begin(), iterEnd = m_metaDataTools.end(); iter != iterEnd; iter++) {
          if ((*iter)->name() == "ToolSvc." + toolInstName) foundTool = true;
       }
       if (!foundTool) {
          if (toolInstName != toolName) {
             toolInstName = toolName + "/" + toolInstName;
          }
          ToolHandle<IMetaDataTool> metadataTool(toolInstName);
          m_metaDataTools.push_back(metadataTool);
          ATH_MSG_DEBUG("Added new MetaDataTool: " << metadataTool->name());
          if (!metadataTool.retrieve().isSuccess()) {
             ATH_MSG_FATAL("Cannot get " << toolInstName);
             return(StatusCode::FAILURE);
          }
       }
    }
    // 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 = 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 = 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 , 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()) {
       delete opqAddr; opqAddr = nullptr;
       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 632 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 161 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.");
    }
    return(StatusCode::SUCCESS);
 }

◆ getPerStreamKeysFor()

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

finaloverridevirtual

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 445 of file MetaDataSvc.cxx.

                                                                               {
    auto iter = m_streamKeys.find( key );
    if( iter == m_streamKeys.end() ) {
       return std::set<std::string>( {key} );
    }
    return iter->second;
 }

◆ 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 357 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(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") {
       if(newMetadataSource(inc).isFailure()) {
          ATH_MSG_ERROR("Could not process new metadata source " << fileName);
       }
    } else if (inc.type() == "EndInputFile") {
       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 109 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);
  
    // 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 565 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,  m_metaDataCont.value() + "(DataHeader)" };
       const std::string parOld[2] = { fileName,  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()) {
                delete opqAddr; opqAddr = nullptr;
                ATH_MSG_WARNING("initInputMetaDataStore: Cannot create proxy for DataHeader, key = " << myVersKey);
             }
          }
       }
       std::list<SG::TransientAddress*> tList;
       if (!loadAddresses(StoreID::METADATA_STORE, tList).isSuccess()) {
          ATH_MSG_ERROR("Unable to load MetaData Proxies");
          return StatusCode::FAILURE;
       }
       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);
 }

◆ interfaceID()

static const InterfaceID& MetaDataSvc::interfaceID ( )

inlinestatic

Retrieve interface ID.

Definition at line 106 of file MetaDataSvc.h.

106 { return IID_MetaDataSvc; }

◆ 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 416 of file MetaDataSvc.cxx.

                                   {
    ATH_MSG_INFO("I/O reinitialization...");
    ATH_MSG_INFO("Dumping InputMetaDataStore: " << m_inputDataStore->dump());
    ATH_MSG_INFO("Dumping OutputMetaDataStore: " << m_outputDataStore->dump());
    for (auto iter = m_metaDataTools.begin(),
          last = m_metaDataTools.end(); iter != last; iter++) {
       ATH_MSG_INFO("Attached MetaDataTool: " << (*iter)->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 206 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(key));
             }
          }
       }
    }
    return(StatusCode::SUCCESS);
 }

◆ lockTools()

void MetaDataSvc::lockTools ( ) const

Definition at line 685 of file MetaDataSvc.cxx.

 {
    ATH_MSG_DEBUG("Locking metadata tools");
    for(auto tool : m_metaDataTools ) {
       ILockableTool *lockable = dynamic_cast<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 238 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;
    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;
       }
       if (!initInputMetaDataStore(fileName).isSuccess()) {
          ATH_MSG_ERROR("Unable to initialize InputMetaDataStore");
          return StatusCode::FAILURE;
       }
    }
    StatusCode rc(StatusCode::SUCCESS);
    for (auto it = m_metaDataTools.begin(); it != m_metaDataTools.end(); ++it) {
       ATH_MSG_DEBUG(" calling beginInputFile on " << (*it)->name() << " for GUID \"" << guid << "\"");
       if ( (*it)->beginInputFile(guid).isFailure() ) {
          ATH_MSG_ERROR("Unable to call beginInputFile for " << (*it)->name());
          rc = StatusCode::FAILURE;
       }
    }
    return rc;
 }

◆ outputDataStore()

virtual StoreGateSvc* MetaDataSvc::outputDataStore ( ) const

inlinefinaloverridevirtual

Definition at line 249 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 198 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 292 of file MetaDataSvc.cxx.

 {
    StatusCode rc(StatusCode::SUCCESS);
    // Check if already called
    if (!m_outputPrepared) {
       for (auto it = m_metaDataTools.begin(); it != m_metaDataTools.end(); ++it) {
          ATH_MSG_DEBUG(" calling metaDataStop for " << (*it)->name());
          if ( (*it)->metaDataStop().isFailure() ) {
             ATH_MSG_ERROR("Unable to call metaDataStop for " << (*it)->name());
             rc = StatusCode::FAILURE;
          }
       }
       if (!m_metaDataTools.release().isSuccess()) {
          ATH_MSG_WARNING("Cannot release " << m_metaDataTools);
       }
    }
    m_outputPrepared=true;
    return rc;
 }

◆ queryInterface()

StatusCode MetaDataSvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)

override

Provide access to the interfaces implemented by this service.

Definition at line 195 of file MetaDataSvc.cxx.

                                                                                    {
    if (riid == this->interfaceID()) {
       *ppvInterface = this;
    } else {
       // Interface is not directly available: try out a base class
       return(base_class::queryInterface(riid, ppvInterface));
    }
    addRef();
    return(StatusCode::SUCCESS);
 }

◆ recordHook()

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

override

Definition at line 659 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 638 of file MetaDataSvc.cxx.

 {
    auto it =  m_handledClasses.find(itemID);
    if (it == m_handledClasses.end()) {
       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 = "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 672 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 434 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 272 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 it = m_metaDataTools.begin(); it != m_metaDataTools.end(); ++it) {
       ATH_MSG_DEBUG(" calling endInputFile on " << (*it)->name() << " for GUID \"" << guid << "\"");
       if ( (*it)->endInputFile(guid).isFailure() ) {
          ATH_MSG_ERROR("Unable to call endInputFile for " << (*it)->name());
          return StatusCode::FAILURE;
       }
    }
    m_allowMetaDataStop = true;
    return StatusCode::SUCCESS;
 }

◆ rootOpenAction()

StatusCode MetaDataSvc::rootOpenAction ( FILEMGR_CALLBACK_ARGS )

Definition at line 428 of file MetaDataSvc.cxx.

                                                             {
    return(StatusCode::SUCCESS);
 }

◆ stop()

StatusCode MetaDataSvc::stop ( )

overridevirtual

stop the metadata service

Definition at line 186 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 389 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 695 of file MetaDataSvc.cxx.

 {
    ATH_MSG_DEBUG("Unlocking metadata tools");
    for(auto tool : m_metaDataTools ) {
       ILockableTool *lockable = dynamic_cast<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 222 of file MetaDataSvc.h.

                                                            {
     return StatusCode::FAILURE;
   }

Friends And Related Function Documentation

◆ SvcFactory< MetaDataSvc >

friend class SvcFactory< MetaDataSvc >

friend

Definition at line 40 of file MetaDataSvc.h.

Member Data Documentation

◆ m_addrCrtr

ServiceHandle<IAddressCreator> MetaDataSvc::m_addrCrtr

private

Definition at line 314 of file MetaDataSvc.h.

◆ m_allowMetaDataStop

bool MetaDataSvc::m_allowMetaDataStop

private

Definition at line 323 of file MetaDataSvc.h.

◆ m_classIDSvc

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

private

Definition at line 318 of file MetaDataSvc.h.

◆ m_clearedInputDataStore

bool MetaDataSvc::m_clearedInputDataStore

private

Definition at line 321 of file MetaDataSvc.h.

◆ m_clearedOutputDataStore

bool MetaDataSvc::m_clearedOutputDataStore

private

Definition at line 322 of file MetaDataSvc.h.

◆ m_fileMgr

ServiceHandle<IFileMgr> MetaDataSvc::m_fileMgr

private

Definition at line 315 of file MetaDataSvc.h.

◆ m_handledClasses

std::set<CLID> MetaDataSvc::m_handledClasses

private

Definition at line 328 of file MetaDataSvc.h.

◆ m_incSvc

ServiceHandle<IIncidentSvc> MetaDataSvc::m_incSvc

private

Definition at line 316 of file MetaDataSvc.h.

◆ m_inputDataStore

ServiceHandle<StoreGateSvc> MetaDataSvc::m_inputDataStore

private

Definition at line 312 of file MetaDataSvc.h.

◆ m_metaDataCont

StringProperty MetaDataSvc::m_metaDataCont

private

MetaDataContainer, POOL container name for MetaData.

Definition at line 336 of file MetaDataSvc.h.

◆ m_metaDataTools

ToolHandleArray<IMetaDataTool> MetaDataSvc::m_metaDataTools

private

MetaDataTools, vector with the MetaData tools.

Definition at line 338 of file MetaDataSvc.h.

◆ m_outputDataStore

ServiceHandle<StoreGateSvc> MetaDataSvc::m_outputDataStore

private

Definition at line 313 of file MetaDataSvc.h.

◆ m_outputPrepared

bool MetaDataSvc::m_outputPrepared

private

Definition at line 324 of file MetaDataSvc.h.

◆ m_outSeqSvc

ServiceHandle<OutputStreamSequencerSvc> MetaDataSvc::m_outSeqSvc

private

Definition at line 317 of file MetaDataSvc.h.

◆ m_persToClid

std::map<std::string, CLID> MetaDataSvc::m_persToClid

private

Definition at line 325 of file MetaDataSvc.h.

◆ m_storageType

long MetaDataSvc::m_storageType

private

Definition at line 320 of file MetaDataSvc.h.

◆ m_streamInKeyMark

const std::string MetaDataSvc::m_streamInKeyMark = "__STREAM["

private

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

Definition at line 330 of file MetaDataSvc.h.

◆ m_streamKeys

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

private

Definition at line 332 of file MetaDataSvc.h.

◆ m_toolForClid

std::map<CLID, std::string> MetaDataSvc::m_toolForClid

private

Definition at line 326 of file MetaDataSvc.h.

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

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ MetaDataSvc()

◆ ~MetaDataSvc()

Member Function Documentation

◆ addProxyToInputMetaDataStore()

◆ currentRangeID()

◆ finalize()

◆ getPerStreamKeysFor()

◆ handle()

◆ initialize()

◆ initInputMetaDataStore()

◆ interfaceID()

◆ io_reinit()

◆ loadAddresses()

◆ lockTools()

◆ newMetadataSource()

◆ outputDataStore()

◆ preLoadAddresses()

◆ prepareOutput()

◆ queryInterface()

◆ recordHook()

◆ remapMetaContCLID()

◆ removeHook()

◆ removeStreamFromKey()

◆ retireMetadataSource()

◆ rootOpenAction()

◆ stop()

◆ transitionMetaDataFile()

◆ unlockTools()

◆ updateAddress()

Friends And Related Function Documentation

◆ SvcFactory< MetaDataSvc >

Member Data Documentation

◆ m_addrCrtr

◆ m_allowMetaDataStop

◆ 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

◆ m_toolForClid