#include </builds/gaudi/Gaudi/GaudiMonitor/src/HistorySvc.h>

Inheritance diagram for HistorySvc:

[legend]

Collaboration diagram for HistorySvc:

[legend]

Public Member Functions
StatusCode	initialize () override

StatusCode	reinitialize () override

StatusCode	finalize () override

StatusCode	stop () override

virtual StatusCode	captureState ()

StatusCode	registerJob () override

StatusCode	listProperties () const override

JobHistory *	getJobHistory () const override

StatusCode	registerSvc (const IService &) override

StatusCode	listProperties (const IService &) const override

ServiceHistory *	getServiceHistory (const IService &) const override

void	getServiceHistory (std::set< ServiceHistory * > &) const override

StatusCode	registerAlg (const Gaudi::Algorithm &) override

StatusCode	listProperties (const Gaudi::Algorithm &) const override

AlgorithmHistory *	getAlgHistory (const Gaudi::Algorithm &) const override

void	getAlgHistory (std::set< AlgorithmHistory * > &) const override

StatusCode	registerAlgTool (const IAlgTool &) override

StatusCode	listProperties (const IAlgTool &) const override

AlgToolHistory *	getAlgToolHistory (const IAlgTool &) const override

void	getAlgToolHistory (std::set< AlgToolHistory * > &) const override

DataHistory *	createDataHistoryObj (const CLID &id, const std::string &key, const std::string &store) override

virtual StatusCode	registerDataHistory (const CLID &id, const std::string &key, const std::string &store)

DataHistory *	getDataHistory (const CLID &id, const std::string &key, const std::string &store) const override

virtual int	getDataHistory (const CLID &id, const std::string &key, const std::string &storeName, std::list< DataHistory * > &dhlist) const

void	handle (const Incident &inc) override

Public Member Functions inherited from extends< Service, IHistorySvc, IIncidentListener >
void const *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast.

StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface.

std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames.

Public Member Functions inherited from Service
const std::string &	name () const override
	Retrieve name of the service.

StatusCode	configure () override

StatusCode	initialize () override

StatusCode	start () override

StatusCode	stop () override

StatusCode	finalize () override

StatusCode	terminate () override

Gaudi::StateMachine::State	FSMState () const override

Gaudi::StateMachine::State	targetFSMState () const override

StatusCode	reinitialize () override

StatusCode	restart () override

StatusCode	sysInitialize () override
	Initialize Service.

StatusCode	sysStart () override
	Initialize Service.

StatusCode	sysStop () override
	Initialize Service.

StatusCode	sysFinalize () override
	Finalize Service.

StatusCode	sysReinitialize () override
	Re-initialize the Service.

StatusCode	sysRestart () override
	Re-initialize the Service.

	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor.

SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator.

template<typename IFace = IService>
SmartIF< IFace >	service (const std::string &name, bool createIf=true) const

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, const std::string &toolTypeAndName, bool createIf=true)
	Declare used tool.

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")

template<class T>
void	addToolsArray (ToolHandleArray< T > &hndlArr)

const std::vector< IAlgTool * > &	tools () const

SmartIF< IAuditorSvc > &	auditorSvc () const
	The standard auditor service.May not be invoked before sysInitialize() has been invoked.

Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

	PropertyHolder ()=default

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
	Helper to wrap a regular data member and use it as a regular property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation.

Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.

StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name

StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string

StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation

StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property

const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name

StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string

const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties

bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name.

Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected

void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)

	PropertyHolder (const PropertyHolder &)=delete

PropertyHolder &	operator= (const PropertyHolder &)=delete

Public Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream)

bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream

Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor.

const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service.

MsgStream &	msgStream () const
	Return an uninitialized MsgStream.

MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts.

MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS)

MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL)

MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING)

MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO)

MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG)

MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE)

MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO)

Private Types
typedef IVersHistoryObj::PropertyList	PropertyList

typedef std::multimap< DHH, DataHistory * >	DataHistMap

typedef DataHistMap::iterator	DHMitr

typedef DataHistMap::const_iterator	DHMCitr

Private Member Functions
void	clearState ()

void	dumpProperties (std::ofstream &) const

void	dumpProperties (const IService &, std::ofstream &) const

void	dumpProperties (const Gaudi::Algorithm &, std::ofstream &) const

void	dumpProperties (const IAlgTool &, std::ofstream &) const

void	dumpState (std::ofstream &) const

void	dumpState (const INamedInterface *, std::ofstream &) const

std::string	dumpProp (const Gaudi::Details::PropertyBase *, const bool isXML=false, int indent=0) const

IAlgorithm *	getCurrentIAlg () const

Private Attributes
Gaudi::Property< bool >	m_dump { this, "Dump", false }

Gaudi::Property< bool >	m_activate { this, "Activate", true }

Gaudi::Property< std::string >	m_outputFile { this, "OutputFile" }

ServiceHandle< IAlgContextSvc >	p_algCtxSvc { this, "AlgContextSvc", "AlgContextSvc" }

bool	m_isInitialized = false

std::map< const Gaudi::Algorithm , AlgorithmHistory >	m_algmap

std::set< const IAlgTool * >	m_ialgtools

std::map< const AlgTool , AlgToolHistory >	m_algtoolmap

std::map< const IService , ServiceHistory >	m_svcmap

std::multimap< DHH, DataHistory * >	m_datMap

std::unique_ptr< JobHistory >	m_jobHistory

SmartIF< IToolSvc >	m_toolSvc

bool	m_outputFileTypeXML = false

Additional Inherited Members
Public Types inherited from extends< Service, IHistorySvc, IIncidentListener >
using	base_class
	Typedef to this class.

using	extend_interfaces_base
	Typedef to the base of this class.

Public Types inherited from Service
using	Factory = Gaudi::PluginService::Factory<IService( const std::string&, ISvcLocator )>

Public Types inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
using	PropertyHolderImpl
	Typedef used to refer to this class from derived classes, as in.

Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using	base_class

Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...

Protected Member Functions inherited from Service
std::vector< IAlgTool * > &	tools ()

	~Service () override

int	outputLevel () const
	get the `Service's` output level

Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	setUpMessaging () const
	Set up local caches.

MSG::Level	resetMessaging ()
	Reinitialize internal states.

void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream.

Protected Attributes inherited from Service
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state.

Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state.

Gaudi::Property< int >	m_outputLevel { this, "OutputLevel", MSG::NIL, "output level" }
	flag indicating whether ToolHandle tools have been added to m_tools

Gaudi::Property< bool >	m_auditorInitialize { this, "AuditInitialize", false, "trigger auditor on initialize()" }

Gaudi::Property< bool >	m_auditorStart { this, "AuditStart", false, "trigger auditor on start()" }

Gaudi::Property< bool >	m_auditorStop { this, "AuditStop", false, "trigger auditor on stop()" }

Gaudi::Property< bool >	m_auditorFinalize { this, "AuditFinalize", false, "trigger auditor on finalize()" }

Gaudi::Property< bool >	m_auditorReinitialize { this, "AuditReinitialize", false, "trigger auditor on reinitialize()" }

Gaudi::Property< bool >	m_auditorRestart { this, "AuditRestart", false, "trigger auditor on restart()" }

Gaudi::Property< bool >	m_autoRetrieveTools

Gaudi::Property< bool >	m_checkToolDeps

SmartIF< IAuditorSvc >	m_pAuditorSvc
	Auditor Service.

Detailed Description

HistorySvc class definition.

Definition at line 46 of file HistorySvc.h.

Member Typedef Documentation

◆ DataHistMap

typedef std::multimap<DHH, DataHistory*> HistorySvc::DataHistMap

private

Definition at line 90 of file HistorySvc.h.

◆ DHMCitr

typedef DataHistMap::const_iterator HistorySvc::DHMCitr

private

Definition at line 92 of file HistorySvc.h.

◆ DHMitr

typedef DataHistMap::iterator HistorySvc::DHMitr

private

Definition at line 91 of file HistorySvc.h.

◆ PropertyList

typedef IVersHistoryObj::PropertyList HistorySvc::PropertyList

private

Definition at line 88 of file HistorySvc.h.

Member Function Documentation

◆ captureState()

StatusCode HistorySvc::captureState ( )

virtual

Get all the Algorithms

Get all the AlgTools

Get all the Services

Definition at line 168 of file HistorySvc.cpp.

                                    {
 
  if ( !m_jobHistory ) {
    m_jobHistory = std::make_unique<JobHistory>();
 
    bool foundAppMgr( false );
    for ( const auto& item : serviceLocator()->getOptsSvc().items() ) {
      m_jobHistory->addProperty( get<0>( item ), get<1>( item ) );
      foundAppMgr |= get<0>( item ).compare( 0, 15, "ApplicationMgr." ) == 0;
    }
 
    if ( !foundAppMgr ) {
      auto ap = service<IProperty>( "ApplicationMgr" );
      if ( !ap ) {
        error() << "could not get the ApplicationMgr" << endmsg;
      } else {
        for ( auto prop : ap->getProperties() ) {
          m_jobHistory->addProperty( "ApplicationMgr." + prop->name(), prop->toString() );
        }
      }
    }
  }
 
  auto algMgr = Gaudi::svcLocator()->as<IAlgManager>();
  if ( !algMgr ) {
    error() << "Could not get AlgManager" << endmsg;
    return StatusCode::FAILURE;
  }
 
  size_t count = 0;
  for ( auto ialg : algMgr->getAlgorithms() ) {
    Gaudi::Algorithm* alg = dynamic_cast<Gaudi::Algorithm*>( ialg );
    if ( !alg ) {
      warning() << "Algorithm " << ialg->name() << " does not inherit from Gaudi::Algorithm. Not registering it."
                << endmsg;
    } else {
      ++count;
      registerAlg( *alg ).ignore();
    }
  }
 
  info() << "Registered " << count << " Algorithms" << endmsg;
 
  m_isInitialized = true;
  for ( auto algtool : m_ialgtools ) {
    ( const_cast<IAlgTool*>( algtool ) )->addRef();
    registerAlgTool( *algtool ).ignore();
  }
 
  info() << "Registered " << m_algtoolmap.size() << " AlgTools" << endmsg;
 
  for ( auto svc : Gaudi::svcLocator()->getServices() ) {
    svc->addRef();
    registerSvc( *svc ).ignore();
  }
 
  info() << "Registered " << Gaudi::svcLocator()->getServices().size() << " Services" << endmsg;
 
  return StatusCode::SUCCESS;
}

◆ clearState()

void HistorySvc::clearState ( )

private

Definition at line 109 of file HistorySvc.cpp.

                            {
  clear( m_algmap );
 
  m_ialgtools.clear();
  clear( m_algtoolmap );
 
  clear( m_svcmap );
}

◆ createDataHistoryObj()

DataHistory * HistorySvc::createDataHistoryObj	(	const CLID &	id,
		const std::string &	key,
		const std::string &	store )

override

Definition at line 410 of file HistorySvc.cpp.

                                                                    {
 
  if ( !m_activate ) return nullptr;
 
  AlgorithmHistory* algHist = nullptr;
 
  IAlgorithm* ialg = getCurrentIAlg();
  if ( !ialg ) {
    ON_DEBUG
    debug() << "Could not discover current Algorithm:" << endl
            << "          object CLID: " << id << "  key: \"" << key << "\"" << endmsg;
    algHist = nullptr;
  } else {
    Gaudi::Algorithm* alg = dynamic_cast<Gaudi::Algorithm*>( ialg );
    if ( alg ) {
      algHist = getAlgHistory( *alg );
    } else {
      warning() << "Could not extract concrete Algorithm:" << endl
                << "          object CLID: " << id << "  key: \"" << key << "\"" << endmsg;
      algHist = nullptr;
    }
  }
  return new DataHistory( id, key, algHist );
}

◆ dumpProp()

std::string HistorySvc::dumpProp	(	const Gaudi::Details::PropertyBase *	prop,
		const bool	isXML = false,
		int	indent = 0 ) const

private

Definition at line 659 of file HistorySvc.cpp.

                                                                                                {
  std::ostringstream ost;
  if ( isXML ) {
    while ( ind > 0 ) {
      ost << " ";
      ind--;
    }
    ost << "<PROPERTY name=\"" << prop->name() << "\" value=\"" << HistoryObj::convert_string( prop->toString() )
        << "\" documentation=\"" << HistoryObj::convert_string( prop->documentation() ) << "\">";
  } else {
    prop->fillStream( ost );
  }
  return ost.str();
}

◆ dumpProperties() [1/4]

void HistorySvc::dumpProperties	(	const Gaudi::Algorithm &	alg,
		std::ofstream &	ofs ) const

private

Definition at line 317 of file HistorySvc.cpp.

                                                                                   {
 
  AlgorithmHistory* hist = getAlgHistory( alg );
 
  if ( !hist ) { return; }
 
  for ( auto prop : hist->properties() ) { ofs << alg.name() << "  " << dumpProp( prop ) << std::endl; }
}

◆ dumpProperties() [2/4]

void HistorySvc::dumpProperties	(	const IAlgTool &	alg,
		std::ofstream &	ofs ) const

private

Definition at line 620 of file HistorySvc.cpp.

                                                                             {
 
  AlgToolHistory* hist = getAlgToolHistory( alg );
 
  if ( !hist ) return;
 
  for ( auto& prop : hist->properties() ) { ofs << alg.name() << "  " << dumpProp( prop ) << std::endl; }
}

◆ dumpProperties() [3/4]

void HistorySvc::dumpProperties	(	const IService &	svc,
		std::ofstream &	ofs ) const

private

Definition at line 555 of file HistorySvc.cpp.

                                                                             {
 
  ServiceHistory* hist = getServiceHistory( svc );
 
  if ( !hist ) return;
 
  for ( auto& prop : hist->properties() ) { ofs << svc.name() << "  " << dumpProp( prop ) << std::endl; }
}

◆ dumpProperties() [4/4]

void HistorySvc::dumpProperties ( std::ofstream & ofs ) const

private

Definition at line 380 of file HistorySvc.cpp.

                                                        {
 
  ofs << "GLOBAL" << std::endl;
  for ( const auto& prop : m_jobHistory->propertyPairs() ) {
    ofs << prop.first << "  " << dumpProp( prop.second.get() ) << std::endl;
  }
 
  ofs << std::endl << "SERVICES" << std::endl;
  for ( const auto& s : m_svcmap ) dumpProperties( *s.first, ofs );
 
  ofs << std::endl << "ALGORITHMS" << std::endl;
  for ( const auto& alg : m_algmap ) dumpProperties( *alg.first, ofs );
 
  ofs << std::endl << "ALGTOOLS" << std::endl;
  for ( const auto& tool : m_algtoolmap ) dumpProperties( *tool.first, ofs );
}

◆ dumpState() [1/2]

void HistorySvc::dumpState	(	const INamedInterface *	in,
		std::ofstream &	ofs ) const

private

Definition at line 747 of file HistorySvc.cpp.

                                                                              {
 
  HistoryObj*      hist  = nullptr;
  IVersHistoryObj* vhist = nullptr;
 
  const IService*         is = nullptr;
  const Gaudi::Algorithm* ia = nullptr;
  const IAlgTool*         it = nullptr;
  if ( ( is = dynamic_cast<const IService*>( in ) ) != nullptr ) {
    ON_VERBOSE
    verbose() << in->name() << " is Service" << endmsg;
    ServiceHistory* o = getServiceHistory( *is );
    hist              = dynamic_cast<HistoryObj*>( o );
    vhist             = dynamic_cast<IVersHistoryObj*>( o );
  } else if ( ( ia = dynamic_cast<const Gaudi::Algorithm*>( in ) ) != nullptr ) {
    ON_VERBOSE
    verbose() << in->name() << " is Alg" << endmsg;
    AlgorithmHistory* o = getAlgHistory( *ia );
    hist                = dynamic_cast<HistoryObj*>( o );
    vhist               = dynamic_cast<IVersHistoryObj*>( o );
  } else if ( ( it = dynamic_cast<const IAlgTool*>( in ) ) != nullptr ) {
    ON_VERBOSE
    verbose() << in->name() << " is AlgTool" << endmsg;
    AlgToolHistory* o = getAlgToolHistory( *it );
    hist              = dynamic_cast<HistoryObj*>( o );
    vhist             = dynamic_cast<IVersHistoryObj*>( o );
  } else {
    error() << "Could not dcast interface to accepted History Obj type for " << in->name() << endmsg;
    return;
  }
 
  if ( !hist || !vhist ) {
    error() << "Could not dcast recognized object to HistoryObj or IVersHistoryObj. This should never happen."
            << endmsg;
    return;
  }
 
  if ( m_outputFileTypeXML ) {
    hist->dump( ofs, true );
  } else {
    ofs << ">> " << vhist->name() << endl << *hist << endl;
  }
}

◆ dumpState() [2/2]

void HistorySvc::dumpState ( std::ofstream & ofs ) const

private

Definition at line 676 of file HistorySvc.cpp.

                                                   {
 
  if ( m_outputFileTypeXML ) {
    // xml header
    ofs << "<?xml version=\"1.0\" ?> " << std::endl;
    ofs << "<!--Test-xml-->" << std::endl;
    ofs << "<SETUP>" << std::endl;
    ofs << "  <GLOBAL>" << std::endl;
  } else {
    ofs << "GLOBAL" << std::endl;
  }
 
  std::string client_currently_open = "start";
  for ( auto& item : m_jobHistory->propertyPairs() ) {
    // client is the name of the component of the current property
    const auto& client = item.first;
    const auto& prp    = item.second;
 
    if ( m_outputFileTypeXML ) {
 
      if ( client != client_currently_open ) {
        if ( client_currently_open != "start" ) ofs << "    </COMPONENT>" << endl;
        ofs << "    <COMPONENT name=\"" << client << "\" class=\"undefined\">" << std::endl;
      }
    } else {
      ofs << client << "  ";
    }
 
    ofs << dumpProp( prp.get(), m_outputFileTypeXML, 6 ) << endl;
 
    client_currently_open = client;
 
    if ( m_outputFileTypeXML ) ofs << "    </COMPONENT>" << endl;
  }
 
  if ( m_outputFileTypeXML ) {
    ofs << "</GLOBAL>" << endl << "<SERVICES>" << endl;
  } else {
    ofs << "SERVICES" << std::endl;
  }
 
  // helper to dump monitored components sorted by name
  auto sortedDump = [&ofs, this]( const auto& map ) {
    std::map<std::string, const INamedInterface*> sorted;
    for ( const auto& item : map ) sorted[item.first->name()] = item.first;
    for ( const auto& item : sorted ) dumpState( item.second, ofs );
  };
 
  sortedDump( m_svcmap );
 
  if ( m_outputFileTypeXML ) {
    ofs << "</SERVICES>" << endl << "<ALGORITHMS> " << endl;
  } else {
    ofs << "ALGORITHMS" << std::endl;
  }
 
  sortedDump( m_algmap );
 
  if ( m_outputFileTypeXML ) {
    ofs << "</ALGORITHMS>" << endl << "<ALGTOOLS> " << endl;
  } else {
    ofs << "ALGTOOLS" << std::endl;
  }
 
  sortedDump( m_algtoolmap );
 
  if ( m_outputFileTypeXML ) { ofs << "</ALGTOOLS>" << endl << "</SETUP>" << endl; }
}

◆ finalize()

StatusCode HistorySvc::finalize ( )

override

Definition at line 260 of file HistorySvc.cpp.

                                {
 
  ON_VERBOSE
  verbose() << "HistorySvc::finalize()" << endmsg;
 
  clearState();
 
  StatusCode status = Service::finalize();
 
  if ( status.isSuccess() ) info() << "Service finalised successfully" << endmsg;
 
  return status;
}

◆ getAlgHistory() [1/2]

AlgorithmHistory * HistorySvc::getAlgHistory ( const Gaudi::Algorithm & alg ) const

override

Definition at line 327 of file HistorySvc.cpp.

                                                                             {
 
  auto itr = m_algmap.find( &alg );
  if ( itr == m_algmap.end() ) {
    warning() << "Algorithm " << alg.name() << " not registered" << endmsg;
    return nullptr;
  }
  return itr->second;
}

◆ getAlgHistory() [2/2]

void HistorySvc::getAlgHistory ( std::set< AlgorithmHistory * > & algs ) const

override

Definition at line 338 of file HistorySvc.cpp.

338{ map_to_set( m_algmap, algs ); }

◆ getAlgToolHistory() [1/2]

AlgToolHistory * HistorySvc::getAlgToolHistory ( const IAlgTool & alg ) const

override

Definition at line 631 of file HistorySvc.cpp.

                                                                         {
 
  const AlgTool* palg = dynamic_cast<const AlgTool*>( &alg );
  auto           itr  = m_algtoolmap.find( palg );
  if ( itr == m_algtoolmap.end() ) {
    warning() << "AlgTool " << alg.name() << " not registered" << endmsg;
    return nullptr;
  }
  return itr->second;
}

◆ getAlgToolHistory() [2/2]

void HistorySvc::getAlgToolHistory ( std::set< AlgToolHistory * > & algs ) const

override

Definition at line 644 of file HistorySvc.cpp.

644{ map_to_set( m_algtoolmap, algs ); }

◆ getCurrentIAlg()

IAlgorithm * HistorySvc::getCurrentIAlg ( ) const

private

Definition at line 401 of file HistorySvc.cpp.

                                             {
  if ( p_algCtxSvc.isSet() ) return p_algCtxSvc->currentAlg();
  warning() << "trying to create DataHistoryObj before "
            << "HistorySvc has been initialized" << endmsg;
  return nullptr;
}

◆ getDataHistory() [1/2]

DataHistory * HistorySvc::getDataHistory	(	const CLID &	id,
		const std::string &	key,
		const std::string &	store ) const

override

Definition at line 470 of file HistorySvc.cpp.

                                                                    {
 
  DHH dhh( id, key );
 
  auto mitr = m_datMap.equal_range( dhh );
  return ( mitr.first != mitr.second ) ? mitr.first->second : nullptr;
}

◆ getDataHistory() [2/2]

int HistorySvc::getDataHistory	(	const CLID &	id,
		const std::string &	key,
		const std::string &	storeName,
		std::list< DataHistory * > &	dhlist ) const

virtual

Definition at line 481 of file HistorySvc.cpp.

                                                                      {
 
  DHH dhh( id, key );
 
  int n( 0 );
 
  auto mitr = m_datMap.equal_range( dhh );
  for ( auto itr = mitr.first; itr != mitr.second; ++itr ) {
    dhlist.push_back( itr->second );
    ++n;
  }
  return n;
}

◆ getJobHistory()

JobHistory * HistorySvc::getJobHistory ( ) const

override

Definition at line 398 of file HistorySvc.cpp.

398{ return m_jobHistory.get(); }

◆ getServiceHistory() [1/2]

ServiceHistory * HistorySvc::getServiceHistory ( const IService & svc ) const

override

Definition at line 525 of file HistorySvc.cpp.

                                                                         {
 
  const IService* psvc = &svc;
  auto            itr  = m_svcmap.find( psvc );
  if ( itr != m_svcmap.end() ) return itr->second;
 
  warning() << "Service " << svc.name() << " not registered" << endmsg;
  return nullptr;
}

◆ getServiceHistory() [2/2]

void HistorySvc::getServiceHistory ( std::set< ServiceHistory * > & svcs ) const

override

Definition at line 536 of file HistorySvc.cpp.

536{ map_to_set( m_svcmap, svcs ); }

◆ handle()

void HistorySvc::handle ( const Incident & inc )

override

Definition at line 648 of file HistorySvc.cpp.

                                                  {
 
  if ( incident.type() == IncidentType::BeginEvent ) {
    if ( captureState().isFailure() ) {
      warning() << "Error capturing state." << endl << "Will try again at next BeginEvent incident" << endmsg;
    }
  }
}

◆ initialize()

StatusCode HistorySvc::initialize ( )

override

Definition at line 120 of file HistorySvc.cpp.

                                  {
 
  StatusCode status = Service::initialize();
  if ( status.isFailure() ) {
    ON_DEBUG
    debug() << "Failed to initialize the base class (Service)" << endmsg;
    return status;
  }
 
  ON_DEBUG
  debug() << "Initializing HistorySvc" << endmsg;
 
  if ( !m_activate ) return StatusCode::SUCCESS;
 
  if ( p_algCtxSvc.retrieve().isFailure() ) {
    error() << "unable to get the AlgContextSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  auto incidentSvc = service<IIncidentSvc>( "IncidentSvc", true );
  if ( !incidentSvc ) {
    error() << "unable to get the IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // create a weak dependency on the ToolSvc, so that it doesn't get deleted
  // before we're done with it in finalize
  m_toolSvc = serviceLocator()->service( "ToolSvc" );
  if ( !m_toolSvc ) {
    error() << "could not retrieve the ToolSvc handle !" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // add listener to be triggered by first BeginEvent with low priority
  // so it gets called first
  const bool rethrow = false;
  const bool oneShot = true; // make the listener called only once
  incidentSvc->addListener( this, IncidentType::BeginEvent, std::numeric_limits<long>::min(), rethrow, oneShot );
 
  m_outputFileTypeXML = ba::iends_with( m_outputFile.value(), ".xml" );
  ON_DEBUG if ( m_outputFileTypeXML ) { debug() << "output format is XML" << endmsg; }
 
  m_isInitialized = true;
 
  return StatusCode::SUCCESS;
}

◆ listProperties() [1/4]

StatusCode HistorySvc::listProperties ( ) const

override

Definition at line 344 of file HistorySvc.cpp.

                                            {
 
  auto& log = info();
 
  log.setColor( MSG::CYAN );
  log << "Dumping properties for all Algorithms (" << m_algmap.size() << ")" << endmsg;
 
  for ( auto& alg : m_algmap ) { listProperties( *alg.first ).ignore(); }
 
  log << MSG::INFO;
  log.setColor( MSG::CYAN );
  log << "Dumping properties for all AlgTools (" << m_algtoolmap.size() << ")" << endmsg;
 
  for ( auto& algtool : m_algtoolmap ) {
    ON_DEBUG
    debug() << " --> " << algtool.second->algtool_name() << endmsg;
    listProperties( *algtool.first ).ignore();
  }
 
  log << MSG::INFO;
  log.setColor( MSG::CYAN );
  log << "Dumping properties for all Services (" << m_svcmap.size() << ")" << endmsg;
 
  for ( auto& svc : m_svcmap ) { listProperties( *svc.first ).ignore(); }
 
  log << MSG::INFO;
  log.setColor( MSG::CYAN );
  log << "Dumping properties for Job";
  log.resetColor();
 
  log << std::endl << *m_jobHistory << endmsg;
 
  return StatusCode::SUCCESS;
}

◆ listProperties() [2/4]

StatusCode HistorySvc::listProperties ( const Gaudi::Algorithm & alg ) const

override

Definition at line 303 of file HistorySvc.cpp.

                                                                       {
 
  info() << "Dumping properties for " << alg.name() << endl;
 
  AlgorithmHistory* hist = getAlgHistory( alg );
 
  if ( !hist ) { return StatusCode::FAILURE; }
 
  info() << alg.name() << " --> " << endl << *hist << endmsg;
 
  return StatusCode::SUCCESS;
}

◆ listProperties() [3/4]

StatusCode HistorySvc::listProperties ( const IAlgTool & alg ) const

override

Definition at line 606 of file HistorySvc.cpp.

                                                                 {
 
  info() << "Dumping properties for " << alg.name() << endl;
 
  AlgToolHistory* hist = getAlgToolHistory( alg );
 
  if ( !hist ) return StatusCode::FAILURE;
 
  info() << alg.name() << " --> " << endl << *hist << endmsg;
 
  return StatusCode::SUCCESS;
}

◆ listProperties() [4/4]

StatusCode HistorySvc::listProperties ( const IService & svc ) const

override

Definition at line 540 of file HistorySvc.cpp.

                                                                 {
 
  info() << "Dumping properties for " << svc.name() << endl;
 
  ServiceHistory* hist = getServiceHistory( svc );
 
  if ( !hist ) return StatusCode::FAILURE;
 
  info() << svc.name() << " --> " << endl << *hist << endmsg;
 
  return StatusCode::SUCCESS;
}

◆ registerAlg()

StatusCode HistorySvc::registerAlg ( const Gaudi::Algorithm & alg )

override

Definition at line 279 of file HistorySvc.cpp.

                                                              {
 
  JobHistory* job = getJobHistory();
  if ( m_algmap.find( &alg ) != m_algmap.end() ) {
    warning() << "Algorithm " << alg.name() << " already registered with HistorySvc" << endmsg;
    return StatusCode::SUCCESS;
  }
 
  ( const_cast<Gaudi::Algorithm*>( &alg ) )->addRef();
 
  m_algmap[&alg] = new AlgorithmHistory( alg, job );
 
  ON_DEBUG {
    auto& log = debug();
    log << "Registering algorithm: ";
    log.setColor( MSG::CYAN );
    log << alg.name() << endmsg;
    log.resetColor();
  }
 
  return StatusCode::SUCCESS;
}

◆ registerAlgTool()

StatusCode HistorySvc::registerAlgTool ( const IAlgTool & ialg )

override

Definition at line 566 of file HistorySvc.cpp.

                                                             {
 
  if ( !m_isInitialized ) {
    if ( !p_algCtxSvc.isSet() ) {
      if ( p_algCtxSvc.retrieve().isFailure() ) {
        error() << "unable to get the AlgContextSvc" << endmsg;
        return StatusCode::FAILURE;
      }
    }
    m_ialgtools.insert( &ialg );
    return StatusCode::SUCCESS;
  }
 
  const AlgTool* alg = dynamic_cast<const AlgTool*>( &ialg );
  if ( !alg ) {
    error() << "Could not dcast IAlgTool \"" << ialg.name() << "\" to an AlgTool" << endmsg;
    return StatusCode::FAILURE;
  }
 
  if ( m_algtoolmap.find( alg ) != m_algtoolmap.end() ) {
    warning() << "AlgTool " << ialg.name() << " already registered in HistorySvc" << endmsg;
    return StatusCode::SUCCESS;
  }
 
  const JobHistory* job = getJobHistory();
  m_algtoolmap[alg]     = new AlgToolHistory( *alg, job );
 
  ON_DEBUG {
    auto& log = debug();
    log << "Registering algtool: ";
    log.setColor( MSG::CYAN );
    log << alg->name() << endmsg;
    log.resetColor();
  }
 
  return StatusCode::SUCCESS;
}

◆ registerDataHistory()

StatusCode HistorySvc::registerDataHistory	(	const CLID &	id,
		const std::string &	key,
		const std::string &	store )

virtual

Definition at line 437 of file HistorySvc.cpp.

                                                                                                             {
 
  DHH dhh( id, key );
 
  auto boundaries = m_datMap.equal_range( dhh );
  auto match      = boundaries.second;
 
  if ( boundaries.first != boundaries.second ) {
    // there is something in the map, let's look for the specific entry
 
    std::string algName;
    IAlgorithm* ialg = getCurrentIAlg();
    if ( ialg ) {
      algName = ialg->name();
    } else {
      algName = "UNKNOWN";
    }
 
    match = std::find_if( boundaries.first, boundaries.second,
                          [&algName]( decltype( boundaries )::first_type::reference p ) -> bool {
                            return p.second->algorithmHistory()->algorithm_name() == algName;
                          } );
  }
 
  if ( match == boundaries.second ) { // not found, crete the entry
    DataHistory* dh = createDataHistoryObj( id, key, storeName );
    m_datMap.insert( pair<DHH, DataHistory*>( dhh, dh ) );
  }
 
  return StatusCode::SUCCESS;
}

◆ registerJob()

StatusCode HistorySvc::registerJob ( )

override

Definition at line 341 of file HistorySvc.cpp.

341{ return StatusCode::SUCCESS; }

◆ registerSvc()

StatusCode HistorySvc::registerSvc ( const IService & svc )

override

Definition at line 498 of file HistorySvc.cpp.

                                                        {
 
  if ( svc.name() == "HistoryStore" ) { return StatusCode::SUCCESS; }
 
  JobHistory*     job  = getJobHistory();
  const IService* psvc = &svc;
  auto            itr  = m_svcmap.find( psvc );
  if ( itr == m_svcmap.end() ) {
 
    ON_DEBUG {
      auto& log = debug();
      log << "Registering Service: ";
      log.setColor( MSG::CYAN );
      log << svc.name() << endmsg;
      log.resetColor();
    }
 
    m_svcmap[psvc] = new ServiceHistory( &svc, job );
 
    ( const_cast<IService*>( psvc ) )->addRef();
  }
 
  return StatusCode::SUCCESS;
}

◆ reinitialize()

StatusCode HistorySvc::reinitialize ( )

override

Definition at line 86 of file HistorySvc.cpp.

                                    {
 
  clearState();
  m_state = Gaudi::StateMachine::OFFLINE;
  return initialize();
}

◆ stop()

StatusCode HistorySvc::stop ( )

override

Definition at line 237 of file HistorySvc.cpp.

                            {
 
  if ( !m_activate ) return StatusCode::SUCCESS;
 
  if ( m_dump ) { listProperties().ignore(); }
 
  if ( !m_outputFile.empty() ) {
    std::ofstream ofs( m_outputFile );
    if ( !ofs ) {
      error() << "Unable to open output file \"m_outputFile\"" << endmsg;
    } else {
      //      dumpProperties(ofs);
      dumpState( ofs );
    }
  }
 
  clearState();
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ m_activate

Gaudi::Property<bool> HistorySvc::m_activate { this, "Activate", true }

private

Definition at line 95 of file HistorySvc.h.

95{ this, "Activate", true };

◆ m_algmap

std::map<const Gaudi::Algorithm*, AlgorithmHistory*> HistorySvc::m_algmap

private

Definition at line 103 of file HistorySvc.h.

◆ m_algtoolmap

std::map<const AlgTool*, AlgToolHistory*> HistorySvc::m_algtoolmap

private

Definition at line 106 of file HistorySvc.h.

◆ m_datMap

std::multimap<DHH, DataHistory*> HistorySvc::m_datMap

private

Definition at line 109 of file HistorySvc.h.

◆ m_dump

Gaudi::Property<bool> HistorySvc::m_dump { this, "Dump", false }

private

Definition at line 94 of file HistorySvc.h.

94{ this, "Dump", false };

◆ m_ialgtools

std::set<const IAlgTool*> HistorySvc::m_ialgtools

private

Definition at line 105 of file HistorySvc.h.

◆ m_isInitialized

bool HistorySvc::m_isInitialized = false

private

Definition at line 101 of file HistorySvc.h.

◆ m_jobHistory

std::unique_ptr<JobHistory> HistorySvc::m_jobHistory

private

Definition at line 111 of file HistorySvc.h.

◆ m_outputFile

Gaudi::Property<std::string> HistorySvc::m_outputFile { this, "OutputFile" }

private

Definition at line 96 of file HistorySvc.h.

96{ this, "OutputFile" };

◆ m_outputFileTypeXML

bool HistorySvc::m_outputFileTypeXML = false

private

Definition at line 127 of file HistorySvc.h.

◆ m_svcmap

std::map<const IService*, ServiceHistory*> HistorySvc::m_svcmap

private

Definition at line 107 of file HistorySvc.h.

◆ m_toolSvc

SmartIF<IToolSvc> HistorySvc::m_toolSvc

private

Definition at line 125 of file HistorySvc.h.

◆ p_algCtxSvc

ServiceHandle<IAlgContextSvc> HistorySvc::p_algCtxSvc { this, "AlgContextSvc", "AlgContextSvc" }

private

Definition at line 97 of file HistorySvc.h.

97{ this, "AlgContextSvc", "AlgContextSvc" };

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

GaudiMonitor/src/HistorySvc.h
GaudiMonitor/src/HistorySvc.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ DataHistMap

◆ DHMCitr

◆ DHMitr

◆ PropertyList

Member Function Documentation

◆ captureState()

◆ clearState()

◆ createDataHistoryObj()

◆ dumpProp()

◆ dumpProperties() [1/4]

◆ dumpProperties() [2/4]

◆ dumpProperties() [3/4]

◆ dumpProperties() [4/4]

◆ dumpState() [1/2]

◆ dumpState() [2/2]

◆ finalize()

◆ getAlgHistory() [1/2]

◆ getAlgHistory() [2/2]

◆ getAlgToolHistory() [1/2]

◆ getAlgToolHistory() [2/2]

◆ getCurrentIAlg()

◆ getDataHistory() [1/2]

◆ getDataHistory() [2/2]

◆ getJobHistory()

◆ getServiceHistory() [1/2]

◆ getServiceHistory() [2/2]

◆ handle()

◆ initialize()

◆ listProperties() [1/4]

◆ listProperties() [2/4]

◆ listProperties() [3/4]

◆ listProperties() [4/4]

◆ registerAlg()

◆ registerAlgTool()

◆ registerDataHistory()

◆ registerJob()

◆ registerSvc()

◆ reinitialize()

◆ stop()

Member Data Documentation

◆ m_activate

◆ m_algmap

◆ m_algtoolmap

◆ m_datMap

◆ m_dump

◆ m_ialgtools

◆ m_isInitialized

◆ m_jobHistory

◆ m_outputFile

◆ m_outputFileTypeXML

◆ m_svcmap

◆ m_toolSvc

◆ p_algCtxSvc