#include <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 *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...

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

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

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

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

StatusCode	sysStart () override
	Initialize Service. More...

StatusCode	sysStop () override
	Initialize Service. More...

StatusCode	sysFinalize () override
	Finalize Service. More...

StatusCode	sysReinitialize () override
	Re-initialize the Service. More...

StatusCode	sysRestart () override
	Re-initialize the Service. More...

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

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

StatusCode	setProperties ()
	Method for setting declared properties to the values specified for the job. More...

template<class T >
StatusCode	service (const std::string &name, const T *&psvc, bool createIf=true) const
	Access a service by name, creating it if it doesn't already exist. More...

template<class T >
StatusCode	service (const std::string &name, T *&psvc, bool createIf=true) const

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

template<class T >
StatusCode	service (const std::string &svcType, const std::string &svcName, T *&psvc) const
	Access a service by name and type, creating it if it doesn't already exist. More...

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

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

Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
	PropertyHolder ()=default

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

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

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

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

StatusCode	setProperty (const Gaudi::Details::PropertyBase &p) override
	set the property form another property More...

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

StatusCode	setProperty (const std::string &n, const std::string &v) override
	set the property from name and the value More...

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

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

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

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

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

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

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

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

MSG::Level	outputLevel () const
	Backward compatibility function for getting the output level. More...

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

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

MsgStream &	msgStream () const
	Return an uninitialized MsgStream. More...

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

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

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

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

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

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

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

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

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

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

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"}

bool	m_isInitialized = false

IAlgContextSvc *	p_algCtxSvc = nullptr

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

IIncidentSvc *	m_incidentSvc = nullptr

SmartIF< IToolSvc >	m_toolSvc

bool	m_outputFileTypeXML = false

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

using	extend_interfaces_base = extend_interfaces< Interfaces... >
	Typedef to the base of this class. More...

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 = PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
	Typedef used to refer to this class from derived classes, as in. More...

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

Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids... >::type
	take union of the ext_iids of all Interfaces... More...

Protected Member Functions inherited from Service
	~Service () override
	Standard Destructor. More...

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

Protected Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
Gaudi::Details::PropertyBase *	property (const std::string &name) const

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

MSG::Level	resetMessaging ()
	Reinitialize internal states. More...

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

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

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

Gaudi::Property< int >	m_outputLevel {this, "OutputLevel", MSG::NIL, "output level"}

Gaudi::Property< bool >	m_auditInit {this, "AuditServices", false, "[[deprecated]] unused"}

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()"}

SmartIF< IAuditorSvc >	m_pAuditorSvc
	Auditor Service. More...

Detailed Description

HistorySvc class definition.

Definition at line 36 of file HistorySvc.h.

Member Typedef Documentation

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

private

Definition at line 80 of file HistorySvc.h.

typedef DataHistMap::const_iterator HistorySvc::DHMCitr

private

Definition at line 82 of file HistorySvc.h.

typedef DataHistMap::iterator HistorySvc::DHMitr

private

Definition at line 81 of file HistorySvc.h.

typedef IVersHistoryObj::PropertyList HistorySvc::PropertyList

private

Definition at line 78 of file HistorySvc.h.

Member Function Documentation

StatusCode HistorySvc::captureState ( )

virtual

Get all the Algorithms

Get all the AlgTools

Get all the Services

Definition at line 160 of file HistorySvc.cpp.

                                     {
 
   if ( !m_jobHistory ) {
     m_jobHistory.reset( new JobHistory );
     IJobOptionsSvc* jo;
     if ( service( "JobOptionsSvc", jo ).isFailure() ) {
       error() << "Could not get jobOptionsSvc - "
               << "not adding properties to JobHistory" << endmsg;
     } else {
 
       bool foundAppMgr( false );
 
       for ( auto& client : jo->getClients() ) {
         if ( client == "ApplicationMgr" ) foundAppMgr = true;
         for ( auto prop : *jo->getProperties( client ) ) { m_jobHistory->addProperty( client, prop ); }
       }
 
       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 ); }
         }
       }
     }
   }
 
 
   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;
 }

void HistorySvc::clearState ( )

private

Definition at line 100 of file HistorySvc.cpp.

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

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

override

Definition at line 408 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 );
 }

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

private

Definition at line 657 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();
 }

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

private

Definition at line 378 of file HistorySvc.cpp.

                                                         {
 
   ofs << "GLOBAL" << std::endl;
   for ( const auto& prop : m_jobHistory->propertyPairs() ) {
     ofs << prop.first << "  " << dumpProp( prop.second ) << 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 );
 }

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

private

Definition at line 553 of file HistorySvc.cpp.

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

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

private

Definition at line 314 of file HistorySvc.cpp.

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

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

private

Definition at line 618 of file HistorySvc.cpp.

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

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

private

Definition at line 674 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 std::string&                  client = item.first;
     const Gaudi::Details::PropertyBase* 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, 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; }
 }

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

private

Definition at line 745 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;
   }
 }

StatusCode HistorySvc::finalize ( )

override

Definition at line 257 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;
 }

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

override

Definition at line 325 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;
 }

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

override

Definition at line 336 of file HistorySvc.cpp.

336 { map_to_set( m_algmap, algs ); }

HistorySvc::m_algmap

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

Definition: HistorySvc.h:94

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

override

Definition at line 629 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;
 }

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

override

Definition at line 642 of file HistorySvc.cpp.

642 { map_to_set( m_algtoolmap, algs ); }

HistorySvc::m_algtoolmap

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

Definition: HistorySvc.h:97

IAlgorithm * HistorySvc::getCurrentIAlg ( ) const

private

Definition at line 399 of file HistorySvc.cpp.

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

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

override

Definition at line 468 of file HistorySvc.cpp.

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

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

virtual

Definition at line 479 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;
 }

JobHistory * HistorySvc::getJobHistory ( ) const

override

Definition at line 396 of file HistorySvc.cpp.

396 { return m_jobHistory.get(); }

std::unique_ptr::get

T get(T...args)

HistorySvc::m_jobHistory

std::unique_ptr< JobHistory > m_jobHistory

Definition: HistorySvc.h:102

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

override

Definition at line 523 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;
 }

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

override

Definition at line 534 of file HistorySvc.cpp.

534 { map_to_set( m_svcmap, svcs ); }

HistorySvc::m_svcmap

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

Definition: HistorySvc.h:98

void HistorySvc::handle ( const Incident & inc )

override

Definition at line 646 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;
     }
   }
 }

StatusCode HistorySvc::initialize ( )

override

Definition at line 111 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;
 
   static const bool CREATEIF( true );
 
   if ( service( "AlgContextSvc", p_algCtxSvc, CREATEIF ).isFailure() ) {
     error() << "unable to get the AlgContextSvc" << endmsg;
     return StatusCode::FAILURE;
   }
 
   if ( service( "IncidentSvc", m_incidentSvc, CREATEIF ).isFailure() ) {
     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
   m_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;
 }

StatusCode HistorySvc::listProperties ( ) const

override

Definition at line 342 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( StatusCode::SUCCESS, true );
 }

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

override

Definition at line 538 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( StatusCode::SUCCESS, true );
 }

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

override

Definition at line 300 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( StatusCode::SUCCESS, true );
 }

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

override

Definition at line 604 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;
 }

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

override

Definition at line 276 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( StatusCode::SUCCESS, true );
 }

StatusCode HistorySvc::registerAlgTool ( const IAlgTool & ialg )

override

Definition at line 564 of file HistorySvc.cpp.

                                                              {
 
   if ( !m_isInitialized ) {
     if ( !p_algCtxSvc ) {
       if ( service( "AlgContextSvc", p_algCtxSvc, true ).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;
 }

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

virtual

Definition at line 435 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;
 }

StatusCode HistorySvc::registerJob ( )

override

Definition at line 339 of file HistorySvc.cpp.

339 { return StatusCode( StatusCode::SUCCESS, true ); }

StatusCode::SUCCESS

constexpr static const auto SUCCESS

Definition: StatusCode.h:85

StatusCode

This class is used for returning status codes from appropriate routines.

Definition: StatusCode.h:50

StatusCode HistorySvc::registerSvc ( const IService & svc )

override

Definition at line 496 of file HistorySvc.cpp.

                                                         {
 
   if ( svc.name() == "HistoryStore" ) { return StatusCode( StatusCode::SUCCESS, true ); }
 
   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( StatusCode::SUCCESS, true );
 }

StatusCode HistorySvc::reinitialize ( )

override

Definition at line 77 of file HistorySvc.cpp.

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

StatusCode HistorySvc::stop ( )

override

Definition at line 234 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

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

private

Definition at line 85 of file HistorySvc.h.

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

private

Definition at line 94 of file HistorySvc.h.

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

private

Definition at line 97 of file HistorySvc.h.

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

private

Definition at line 100 of file HistorySvc.h.

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

private

Definition at line 84 of file HistorySvc.h.

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

private

Definition at line 96 of file HistorySvc.h.

IIncidentSvc* HistorySvc::m_incidentSvc = nullptr

private

Definition at line 116 of file HistorySvc.h.

bool HistorySvc::m_isInitialized = false

private

Definition at line 90 of file HistorySvc.h.

std::unique_ptr<JobHistory> HistorySvc::m_jobHistory

private

Definition at line 102 of file HistorySvc.h.

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

private

Definition at line 86 of file HistorySvc.h.

bool HistorySvc::m_outputFileTypeXML = false

private

Definition at line 119 of file HistorySvc.h.

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

private

Definition at line 98 of file HistorySvc.h.

SmartIF<IToolSvc> HistorySvc::m_toolSvc

private

Definition at line 117 of file HistorySvc.h.

IAlgContextSvc* HistorySvc::p_algCtxSvc = nullptr

private

Definition at line 92 of file HistorySvc.h.

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

Member Function Documentation

Member Data Documentation