MetaDataSvc Class Reference

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 &tokenStr) 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 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::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 53 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 )
{}

~MetaDataSvc()

MetaDataSvc::~MetaDataSvc ( )

virtualdefault

Destructor.

Member Function Documentation

addProxyToInputMetaDataStore()

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

private

Definition at line 388 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;
   // className is the persistent class sent by the client ([PNAME=]). xAOD metadata is written by
   // T_AthenaPoolxAODCnv / T_AthenaPoolAuxContainerCnv, whose persistent class is the transient
   // class, known to ClassIDSvc by its type-info name. The T/P metadata classes (EventStreamInfo,
   // IOVMetaDataContainer, ByteStreamMetadataContainer) are named <transient>_p<N>, and ClassIDSvc
   // knows <transient>; that is a convention, not enforced (PyUtils/MetaReader.py relies on it too).
   // A metadata class that fits neither fails here.
   CLID clid = CLID_NULL;
   if (m_classIDSvc->getIDOfTypeInfoName(className, clid).isFailure()) {
      const std::size_t ppos = className.rfind("_p");
      const bool isTP = ppos != std::string::npos && ppos + 2 < className.size()
         && std::all_of(className.begin() + ppos + 2, className.end(), [](unsigned char c) { return std::isdigit(c); });
      if (!isTP || m_classIDSvc->getIDOfTypeName(className.substr(0, ppos), clid).isFailure()) {
         ATH_MSG_ERROR("addProxyToInputMetaDataStore: no CLID for persistent class {} in {}", className, tokenStr);
         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 = std::format("{}{}{}{}", keyName, m_streamInKeyMark, fileName, "]");
      ATH_MSG_DEBUG("Recording {} as {}", keyName, 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 {} as {}", keyName, 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: {}#{} from file: {}",
                    clid, keyName, 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 534 of file MetaDataSvc.cxx.

{
   const EventContext& ctx = Gaudi::Hive::currentContext();
   return m_outSeqSvc.isValid()? m_outSeqSvc->currentRangeID(ctx) : "";
}

finalize()

StatusCode MetaDataSvc::finalize ( )

overridevirtual

finalize the metadata service at the end of the job

Definition at line 120 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 380 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 292 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() {} for {}", inc.type(), fileName);
 
   if (inc.type() == "FirstInputFile") {
      // Register open/close callback actions
      using namespace std::placeholders;
      Io::bfcn_action_t boa = std::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 66 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 467 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")
      };
      if (m_inputDataStore->contains<DataHeader>(name())) {
         ATH_MSG_DEBUG("initInputMetaDataStore: MetaData Store already contains DataHeader, key = {}", name());
      } else {
         const unsigned long ipar[2] = { 0 , 0 };
         IOpaqueAddress* opqAddr = nullptr;
         if (m_addrCrtr->createAddress(m_storageType, ClassID_traits<DataHeader>::ID(), par, ipar, opqAddr).isSuccess()
          || m_addrCrtr->createAddress(m_storageType, ClassID_traits<DataHeader>::ID(), parOld, ipar, opqAddr).isSuccess()) {
            if (m_inputDataStore->recordAddress(name(), opqAddr).isFailure()) {
               ATH_MSG_WARNING("initInputMetaDataStore: Cannot create proxy for DataHeader, key = {}", name());
            }
         }
      }
      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 = {}, key = {}",
                         clid, tad->name());
         if (m_inputDataStore->contains(tad->clID(), tad->name())) {
            ATH_MSG_DEBUG("initInputMetaDataStore: MetaData Store already contains clid = {}, key = {}",
                          clid, tad->name());
         } else {
            if (!m_inputDataStore->recordAddress(tad->name(), tad->address())) {
               ATH_MSG_ERROR("initInputMetaDataStore: Cannot create proxy for clid = {}, key = {}",
                             clid, 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 {}/{} to {}",
                                  clid, tad->name(), 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 351 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 metadata object.

loads the DataHeader and adds addresses of objects from DataHeaderElements to the tads

See also

DataHeader

Parameters

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

Returns

FAILURE the DataHeader could not be retrieved, else SUCCESS

Definition at line 157 of file MetaDataSvc.cxx.

                                                                                        {
   if (storeID != StoreID::METADATA_STORE) { // should this (also) run in the INPUT_METADATA_STORE?
      return(StatusCode::SUCCESS);
   }
   if (!m_inputDataStore->contains<DataHeader>( name()) ) {
      return(StatusCode::SUCCESS);
   }
   const DataHeader* dataHeader = nullptr;
   ATH_CHECK( m_inputDataStore->retrieve( dataHeader, name()) );
   for (const DataHeaderElement& dhe : *dataHeader) {
      const CLID clid = dhe.getPrimaryClassID();
      if (clid != ClassID_traits<DataHeader>::ID()) {
         tads.push_back(dhe.getAddress(m_storageType, dhe.getKey()));
      }
   }
   return(StatusCode::SUCCESS);
}

lockTools()

void MetaDataSvc::lockTools

(

)

const

Definition at line 585 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 175 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 {} for GUID \"{}\"",
                    tool->name(), 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 233 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 226 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 561 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 {} ClassID: {}", typeName, itemID);
  }
}

remapMetaContCLID()

CLID MetaDataSvc::remapMetaContCLID

(

const CLID &

item_id

)

const

Definition at line 541 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 {} to {} for output",
                   contName, itemName);
     if (m_classIDSvc->getIDOfTypeName(contName, contID).isSuccess())
       return contID;
   }
 
   return itemID;
}

removeHook()

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

override

Definition at line 573 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 {} ClassID: {}",
                    typeName, 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 368 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 208 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 {} for GUID \"{}\"",
                    tool->name(), guid);
      ATH_CHECK(tool->endInputFile(guid));
   }
   m_allowMetaDataStop = true;
   return StatusCode::SUCCESS;
}

rootOpenAction()

StatusCode MetaDataSvc::rootOpenAction

(

FILEMGR_CALLBACK_ARGS

)

Definition at line 362 of file MetaDataSvc.cxx.

                                                            {
   return(StatusCode::SUCCESS);
}

stop()

StatusCode MetaDataSvc::stop ( )

overridevirtual

stop the metadata service

Definition at line 148 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 324 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 593 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 206 of file MetaDataSvc.h.

                                                           {
    return StatusCode::FAILURE;
  }

Member Data Documentation

m_addrCrtr

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

private

Definition at line 298 of file MetaDataSvc.h.

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

m_allowMetaDataStop

bool MetaDataSvc::m_allowMetaDataStop {false}

private

Definition at line 307 of file MetaDataSvc.h.

{false};

m_beginInputFileSeen

bool MetaDataSvc::m_beginInputFileSeen {false}

private

Definition at line 308 of file MetaDataSvc.h.

{false};

m_classIDSvc

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

private

Definition at line 302 of file MetaDataSvc.h.

{"ClassIDSvc", name()};

m_clearedInputDataStore

bool MetaDataSvc::m_clearedInputDataStore {true}

private

Definition at line 305 of file MetaDataSvc.h.

{true};

m_clearedOutputDataStore

bool MetaDataSvc::m_clearedOutputDataStore {false}

private

Definition at line 306 of file MetaDataSvc.h.

{false};

m_fileMgr

ServiceHandle<IFileMgr> MetaDataSvc::m_fileMgr

private

Definition at line 299 of file MetaDataSvc.h.

m_handledClasses

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

private

Definition at line 311 of file MetaDataSvc.h.

{};

m_incSvc

ServiceHandle<IIncidentSvc> MetaDataSvc::m_incSvc

private

Definition at line 300 of file MetaDataSvc.h.

m_inputDataStore

ServiceHandle<StoreGateSvc> MetaDataSvc::m_inputDataStore

private

Definition at line 296 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 319 of file MetaDataSvc.h.

{this, "MetaDataContainer", ""};

m_metaDataTools

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

private

MetaDataTools, vector with the MetaData tools.

Definition at line 321 of file MetaDataSvc.h.

{this, "MetaDataTools", {}};

m_outputDataStore

ServiceHandle<StoreGateSvc> MetaDataSvc::m_outputDataStore

private

Definition at line 297 of file MetaDataSvc.h.

m_outputPrepared

bool MetaDataSvc::m_outputPrepared {false}

private

Definition at line 309 of file MetaDataSvc.h.

{false};

m_outSeqSvc

ServiceHandle<OutputStreamSequencerSvc> MetaDataSvc::m_outSeqSvc

private

Definition at line 301 of file MetaDataSvc.h.

m_storageType

long MetaDataSvc::m_storageType {0L}

private

Definition at line 304 of file MetaDataSvc.h.

{0L};

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

{"__STREAM["};

m_streamKeys

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

private

Definition at line 315 of file MetaDataSvc.h.

{};

---

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

• MetaDataSvc.h
• MetaDataSvc.cxx