HistorySvc Class Reference

HistorySvc class definition. More...

#include <src/HistorySvc.h>

Inheritance diagram for HistorySvc:

Collaboration diagram for HistorySvc:

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 Algorithm &) override
StatusCode	listProperties (const Algorithm &) const override
AlgorithmHistory *	getAlgHistory (const 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
	~HistorySvc () override=default
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...
	~extends () override=default
	Virtual destructor. 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
	~PropertyHolder () override=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, TYPE &value, const std::string &doc="none") const
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
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, GaudiHandleBase &ref, const std::string &doc="none")
	Specializations for various GaudiHandles. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, GaudiHandleArrayBase &ref, const std::string &doc="none")
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, DataObjectHandleBase &ref, const std::string &doc="none")
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor. More...
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...
MSG::Level	msgLevel () const
	get the output level from the embedded MsgStream More...
MSG::Level	outputLevel () const __attribute__((deprecated))
	Backward compatibility function for getting the output level. More...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...
Public Member Functions inherited from extend_interfaces< Interfaces... >
	~extend_interfaces () override=default
	Virtual destructor. 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 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 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
typedef Gaudi::PluginService::Factory< IService *, const std::string &, ISvcLocator * >	Factory
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 > >
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 84 of file HistorySvc.h.

typedef DataHistMap::const_iterator HistorySvc::DHMCitr

private

Definition at line 86 of file HistorySvc.h.

typedef DataHistMap::iterator HistorySvc::DHMitr

private

Definition at line 85 of file HistorySvc.h.

typedef IVersHistoryObj::PropertyList HistorySvc::PropertyList

private

Definition at line 82 of file HistorySvc.h.

Constructor & Destructor Documentation

HistorySvc::~HistorySvc ( )

overridedefault

Member Function Documentation

StatusCode HistorySvc::captureState ( )

virtual

Get all the Algorithms

Get all the AlgTools

Get all the Services

Definition at line 169 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() ) {
    Algorithm* alg = dynamic_cast<Algorithm*>( ialg );
    if ( !alg ) {
      warning() << "Algorithm " << ialg->name() << " does not inherit from 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 107 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 443 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 {
    Algorithm* alg = dynamic_cast<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 713 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 411 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 598 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 Algorithm &  alg, std::ofstream &  ofs  ) const

private

Definition at line 336 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 669 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 731 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;
  }

  for ( auto& item : m_svcmap ) {
    const IService* svc = item.first;
    dumpState( svc, ofs );
  }

  if ( m_outputFileTypeXML ) {
    ofs << "</SERVICES>" << endl << "<ALGORITHMS> " << endl;
  } else {
    ofs << "ALGORITHMS" << std::endl;
  }

  for ( auto& item : m_algmap ) {
    const Algorithm* alg = item.first;
    dumpState( alg, ofs );
  }

  if ( m_outputFileTypeXML ) {
    ofs << "</ALGORITHMS>" << endl << "<ALGTOOLS> " << endl;
  } else {
    ofs << "ALGTOOLS" << std::endl;
  }

  for ( auto& item : m_algtoolmap ) {
    const AlgTool* algtool = item.first;
    dumpState( algtool, ofs );
  }

  if ( m_outputFileTypeXML ) {
    ofs << "</ALGTOOLS>" << endl << "</SETUP>" << endl;
  }
}

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

private

Definition at line 807 of file HistorySvc.cpp.

{

  HistoryObj* hist       = nullptr;
  IVersHistoryObj* vhist = nullptr;

  const IService* is  = nullptr;
  const 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 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 273 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 Algorithm &  alg ) const

override

Definition at line 352 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 364 of file HistorySvc.cpp.

{ map_to_set( m_algmap, algs ); }

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

override

Definition at line 683 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 697 of file HistorySvc.cpp.

{ map_to_set( m_algtoolmap, algs ); }

IAlgorithm * HistorySvc::getCurrentIAlg ( ) const

private

Definition at line 433 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 505 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 517 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 430 of file HistorySvc.cpp.

{ return m_jobHistory.get(); }

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

override

Definition at line 566 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 578 of file HistorySvc.cpp.

{ map_to_set( m_svcmap, svcs ); }

void HistorySvc::handle ( const Incident &  inc )

override

Definition at line 701 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 119 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 370 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 582 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 Algorithm &  alg ) const

override

Definition at line 319 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 654 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 Algorithm &  alg )

override

Definition at line 293 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<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 612 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 471 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 367 of file HistorySvc.cpp.

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

StatusCode HistorySvc::registerSvc ( const IService &  svc )

override

Definition at line 535 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 80 of file HistorySvc.cpp.

{

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

StatusCode HistorySvc::stop ( )

override

Definition at line 247 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 89 of file HistorySvc.h.

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

private

Definition at line 98 of file HistorySvc.h.

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

private

Definition at line 101 of file HistorySvc.h.

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

private

Definition at line 104 of file HistorySvc.h.

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

private

Definition at line 88 of file HistorySvc.h.

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

private

Definition at line 100 of file HistorySvc.h.

IIncidentSvc* HistorySvc::m_incidentSvc = nullptr

private

Definition at line 120 of file HistorySvc.h.

bool HistorySvc::m_isInitialized = false

private

Definition at line 94 of file HistorySvc.h.

std::unique_ptr<JobHistory> HistorySvc::m_jobHistory

private

Definition at line 106 of file HistorySvc.h.

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

private

Definition at line 90 of file HistorySvc.h.

bool HistorySvc::m_outputFileTypeXML = false

private

Definition at line 123 of file HistorySvc.h.

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

private

Definition at line 102 of file HistorySvc.h.

SmartIF<IToolSvc> HistorySvc::m_toolSvc

private

Definition at line 121 of file HistorySvc.h.

IAlgContextSvc* HistorySvc::p_algCtxSvc = nullptr

private

Definition at line 96 of file HistorySvc.h.

---

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

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