Default implementation of the IIncidentSvc interface. More...

#include <src/IncidentSvc/IncidentSvc.h>

Inheritance diagram for IncidentSvc:

Collaboration diagram for IncidentSvc:

Classes
struct	Listener

Public Member Functions
StatusCode	initialize () override

StatusCode	finalize () override

void	addListener (IIncidentListener *lis, const std::string &type="", long priority=0, bool rethrow=false, bool singleShot=false) override

void	removeListener (IIncidentListener *l, const std::string &type="") override

void	fireIncident (const Incident &incident) override

void	getListeners (std::vector< IIncidentListener * > &lis, const std::string &type="") const override

	IncidentSvc (const std::string &name, ISvcLocator *svc)

	~IncidentSvc () override

Public Member Functions inherited from extends< BASE, Interfaces >
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...

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 extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...

	~extend_interfaces () override=default
	Virtual destructor. More...

Private Types
typedef std::vector< Listener >	ListenerList

typedef GaudiUtils::HashMap< Gaudi::StringKey, std::unique_ptr< ListenerList > >	ListenerMap

Private Member Functions
ListenerMap::iterator	removeListenerFromList (ListenerMap::iterator, IIncidentListener *item, bool scheduleRemoval)

void	i_fireIncident (const Incident &incident, const std::string &type)
	Internal function to allow incidents listening to all events. More...

Private Attributes
ListenerMap	m_listenerMap
	List of auditor names. More...

const std::string *	m_currentIncidentType = nullptr
	Incident being fired. More...

std::recursive_mutex	m_listenerMapMutex
	Mutex to synchronize access to m_listenerMap. More...

ChronoEntity	m_timer
	timer & it's lock More...

bool	m_timerLock = false

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

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

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

using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Detailed Description

Default implementation of the IIncidentSvc interface.

This implementation is thread-safe with the following features:

Calls to fireIncident(), addListener() and removeListener() are synchronized across threads.
Calls to IIncidentListener::handle() are serialized, i.e. at any time there is at most one incident handler being executed across all threads.

Definition at line 33 of file IncidentSvc.h.

Member Typedef Documentation

typedef std::vector<Listener> IncidentSvc::ListenerList

private

Definition at line 49 of file IncidentSvc.h.

typedef GaudiUtils::HashMap<Gaudi::StringKey, std::unique_ptr<ListenerList> > IncidentSvc::ListenerMap

private

Definition at line 50 of file IncidentSvc.h.

Constructor & Destructor Documentation

IncidentSvc::IncidentSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 51 of file IncidentSvc.cpp.

52 : base_class(name, svc)

53 {}

gaudiComponentHelp.name

name

Definition: gaudiComponentHelp.py:28

extends::base_class

extends base_class

Typedef to this class.

Definition: extends.h:14

IncidentSvc::~IncidentSvc ( )

override

Definition at line 55 of file IncidentSvc.cpp.

 {
   std::unique_lock<std::recursive_mutex> lock(m_listenerMapMutex);
 }

Member Function Documentation

void IncidentSvc::addListener	(	IIncidentListener *	lis,
		const std::string &	type = `""`,
		long	priority = `0`,
		bool	rethrow = `false`,
		bool	singleShot = `false`
	)

override

Definition at line 94 of file IncidentSvc.cpp.

 {
   static const std::string all{ "ALL" };
   std::unique_lock<std::recursive_mutex> lock(m_listenerMapMutex);
 
   const std::string& ltype = ( !type.empty() ? type : all );
 
   // find if the type already exists
   auto itMap = m_listenerMap.find( ltype );
   if( itMap == m_listenerMap.end() ) {
     // if not found, create and insert now a list of listeners
     auto p = m_listenerMap.insert( { ltype, std::unique_ptr<ListenerList>( new ListenerList() )  } );
     if ( !p.second ) { /* OOPS */ }
     itMap = p.first;
   }
   auto& llist = *itMap->second;
   // add Listener ordered by priority -- higher priority first,
   // and then add behind listeneres with the same priority
   // -- so we skip over all items with higher or same priority
   auto i = std::partition_point( std::begin(llist),std::end(llist),
                                  [&](const Listener& j) { return j.priority >= prio; } );
   // We insert before the current position
   DEBMSG << "Adding [" << type << "] listener '" << getListenerName(lis)
          << "' with priority " << prio << endmsg;
   llist.emplace(i, lis, prio, rethrow, singleShot);
 }

StatusCode IncidentSvc::finalize ( )

override

Definition at line 80 of file IncidentSvc.cpp.

 {
   DEBMSG << m_timer.outputUserTime( "Incident  timing: Mean(+-rms)/Min/Max:%3%(+-%4%)/%6%/%7%[ms] " , System::milliSec )
          << m_timer.outputUserTime ( "Total:%2%[s]" , System::Sec ) << endmsg ;
 
   // Finalize this specific service
   StatusCode sc = Service::finalize();
   if ( UNLIKELY(sc.isFailure()) ) { return sc; }
 
   return StatusCode::SUCCESS;
 }

void IncidentSvc::fireIncident ( const Incident & incident )

override

Definition at line 246 of file IncidentSvc.cpp.

 {
 
   Gaudi::Utils::LockedChrono timer ( m_timer , m_timerLock ) ;
 
   // Call specific listeners
   i_fireIncident(incident, incident.type());
   // Try listeners registered for ALL incidents
   if ( incident.type() != "ALL" ){ // avoid double calls if somebody fires the incident "ALL"
     i_fireIncident(incident, "ALL");
   }
 }

void IncidentSvc::getListeners	(	std::vector< IIncidentListener * > &	lis,
		const std::string &	type = `""`
	)		const

override

Definition at line 261 of file IncidentSvc.cpp.

 {
   static const std::string ALL { "ALL" };
   std::unique_lock<std::recursive_mutex> lock(m_listenerMapMutex);
 
   const std::string&  ltype = ( !type.empty() ? type : ALL );
 
   l.clear();
   auto i = m_listenerMap.find( ltype );
   if (i != m_listenerMap.end()) {
       l.reserve(i->second->size());
       std::transform( std::begin(*i->second), std::end(*i->second),
                       std::back_inserter(l),
                       [](const Listener& j) { return j.iListener; });
   }
 }

void IncidentSvc::i_fireIncident	(	const Incident &	incident,
		const std::string &	type
	)

private

Internal function to allow incidents listening to all events.

Definition at line 174 of file IncidentSvc.cpp.

 {
 
   std::unique_lock<std::recursive_mutex> lock(m_listenerMapMutex);
 
   // Wouldn't it be better to write a small 'ReturnCode' service which
   // looks for these 'special' incidents and does whatever needs to
   // be done instead of making a special case here?
 
   // Special case: FailInputFile incident must set the application return code
   if ( incident.type() == IncidentType::FailInputFile ||
        incident.type() == IncidentType::CorruptedInputFile ) {
     auto appmgr = serviceLocator()->as<IProperty>();
     Gaudi::setAppReturnCode(appmgr,
                             incident.type() == IncidentType::FailInputFile ?
                                   Gaudi::ReturnCode::FailInput :
                                   Gaudi::ReturnCode::CorruptedInput
                            ).ignore();
   }
 
   auto ilisteners = m_listenerMap.find( listenerType );
   if ( m_listenerMap.end() == ilisteners ) return;
 
   // setting this pointer will avoid that a call to removeListener() during
   // the loop triggers a segfault
   m_currentIncidentType = &incident.type();
 
   bool firedSingleShot = false;
 
   auto& listeners = *ilisteners->second;
 
   for( auto& listener : listeners )
   {
 
     VERMSG << "Calling '" << getListenerName(listener.iListener)
            << "' for incident [" << incident.type() << "]" << endmsg;
 
     // handle exceptions if they occur
     try {
       listener.iListener->handle(incident);
     }
     catch( const GaudiException& exc ) {
       error() << "Exception with tag=" << exc.tag() << " is caught"
                  " handling incident" << m_currentIncidentType << endmsg;
       error() <<  exc  << endmsg;
       if ( listener.rethrow ) { throw exc; }
     }
     catch( const std::exception& exc ) {
      error() << "Standard std::exception is caught"
           " handling incident" << m_currentIncidentType << endmsg;
       error() << exc.what()  << endmsg;
       if ( listener.rethrow ) { throw exc; }
     }
     catch(...) {
       error() << "UNKNOWN Exception is caught"
           " handling incident" << m_currentIncidentType << endmsg;
       if ( listener.rethrow ) { throw; }
     }
     // check wheter one of the listeners is singleShot
     firedSingleShot |= listener.singleShot;
   }
   if (firedSingleShot) {
     // remove all the singleshot listeners that got there shot...
     listeners.erase( std::remove_if( std::begin(listeners),std::end(listeners), isSingleShot ),
                      std::end(listeners) ) ;
     if (listeners.empty()) m_listenerMap.erase(ilisteners);
   }
 
   m_currentIncidentType = nullptr;
 }

StatusCode IncidentSvc::initialize ( )

override

Definition at line 62 of file IncidentSvc.cpp.

 {
   // initialize the Service Base class
   StatusCode sc = Service::initialize();
   if ( sc.isFailure() ) return sc;
 
   m_currentIncidentType = nullptr;
 
   // set my own (IncidentSvc) properties via the jobOptionService
   sc = setProperties();
   if ( UNLIKELY(sc.isFailure()) )
   {
     error() << "Could not set my properties" << endmsg;
     return sc;
   }
   return StatusCode::SUCCESS;
 }

void IncidentSvc::removeListener	(	IIncidentListener *	l,
		const std::string &	type = `""`
	)

override

Definition at line 148 of file IncidentSvc.cpp.

 {
   std::unique_lock<std::recursive_mutex> lock(m_listenerMapMutex);
 
   bool scheduleForRemoval = ( m_currentIncidentType
                               && type == *m_currentIncidentType );
   if( type.empty() ) {
     auto i =  std::begin(m_listenerMap);
     while ( i != std::end(m_listenerMap) ) {
       i = removeListenerFromList( i, lis, scheduleForRemoval );
     }
   } else {
     auto i = m_listenerMap.find( type );
     if ( i != m_listenerMap.end() ) removeListenerFromList( i, lis, scheduleForRemoval );
   }
 }

IncidentSvc::ListenerMap::iterator IncidentSvc::removeListenerFromList	(	ListenerMap::iterator	i,
		IIncidentListener *	item,
		bool	scheduleRemoval
	)

private

Definition at line 124 of file IncidentSvc.cpp.

 {
     auto match = [&](ListenerList::const_reference j )
                  { return !item || item == j.iListener;  };
 
     auto& c = *(i->second);
     if (!scheduleRemoval) {
         ON_DEBUG std::for_each( std::begin(c), std::end(c),
                                 [&](ListenerList::const_reference j) {
           if (match(j)) debug() << "Removing [" << i->first << "] listener '"
                                << getListenerName(j.iListener) << "'" << endmsg;
         });
         c.erase( std::remove_if( std::begin(c), std::end(c), match ),
                  std::end(c) );
     } else {
         std::for_each( std::begin(c), std::end(c), [&](Listener& i) {
             if (match(i)) i.singleShot = true; // will trigger removal as soon as it is safe
         });
     }
     return c.empty() ? m_listenerMap.erase(i) : std::next(i);
 }

Member Data Documentation

const std::string* IncidentSvc::m_currentIncidentType = nullptr

private

Incident being fired.

It is used to know if we can safely remove a listener or we have to schedule its removal for later.

Definition at line 90 of file IncidentSvc.h.

ListenerMap IncidentSvc::m_listenerMap

private

List of auditor names.

Definition at line 86 of file IncidentSvc.h.

std::recursive_mutex IncidentSvc::m_listenerMapMutex

mutableprivate

Mutex to synchronize access to m_listenerMap.

Definition at line 93 of file IncidentSvc.h.

ChronoEntity IncidentSvc::m_timer

mutableprivate

timer & it's lock

Definition at line 96 of file IncidentSvc.h.

bool IncidentSvc::m_timerLock = false

mutableprivate

Definition at line 97 of file IncidentSvc.h.

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

GaudiCoreSvc/src/IncidentSvc/IncidentSvc.h
GaudiCoreSvc/src/IncidentSvc/IncidentSvc.cpp

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation