IncidentSvc Class Reference

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	fireIncident (std::unique_ptr< Incident > incident) override
void	getListeners (std::vector< IIncidentListener * > &lis, const std::string &type="") const override
	IncidentSvc (const std::string &name, ISvcLocator *svc)
	~IncidentSvc () override
IIncidentSvc::IncidentPack	getIncidents (const EventContext *ctx) override
Public Member Functions inherited from extends< Service, IIncidentSvc >
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 std::list< Listener >	ListenerList
typedef GaudiUtils::HashMap< Gaudi::StringKey, std::unique_ptr< ListenerList > >	ListenerMap
typedef tbb::concurrent_queue< Incident * >	IncQueue_t

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
tbb::concurrent_unordered_map< EventContext, IncQueue_t, EventContextHash, EventContextHash >	m_firedIncidents

Additional Inherited Members
Public Types inherited from extends< Service, IIncidentSvc >
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

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 38 of file IncidentSvc.h.

Member Typedef Documentation

typedef tbb::concurrent_queue<Incident*> IncidentSvc::IncQueue_t

private

Definition at line 102 of file IncidentSvc.h.

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

private

Definition at line 54 of file IncidentSvc.h.

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

private

Definition at line 55 of file IncidentSvc.h.

Constructor & Destructor Documentation

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

Definition at line 49 of file IncidentSvc.cpp.

: base_class( name, svc ) {}

IncidentSvc::~IncidentSvc ( )

override

Definition at line 51 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 91 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::make_unique<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 71 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;

  {
    // clear the local storage of allocated Incident objects.
    std::unique_lock<std::recursive_mutex> lock( m_listenerMapMutex );
    for ( auto& fi : m_firedIncidents ) {
      std::for_each( fi.second.unsafe_begin(), fi.second.unsafe_end(), []( auto i ) { delete i; } );
      fi.second.clear();
    }
    m_firedIncidents.clear();
  }

  // Finalize this specific service
  return Service::finalize();
}

void IncidentSvc::fireIncident ( const Incident &  incident )

override

Definition at line 225 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::fireIncident ( std::unique_ptr< Incident >  incident )

override

Definition at line 237 of file IncidentSvc.cpp.

                                                                 {

  DEBMSG << "Async incident '" << incident->type() << "' fired on context " << incident->context() << endmsg;
  auto ctx = incident->context();
  auto res = m_firedIncidents.insert( std::make_pair( ctx, IncQueue_t() ) );
  res.first->second.push( incident.release() );
}

IIncidentSvc::IncidentPack IncidentSvc::getIncidents ( const EventContext *  ctx )

override

Definition at line 263 of file IncidentSvc.cpp.

                                                                            {
  IIncidentSvc::IncidentPack p;
  if ( ctx ) {
    auto incs = m_firedIncidents.find( *ctx );
    if ( incs != m_firedIncidents.end() ) {
      Incident* inc( 0 );

      DEBMSG << "Collecting listeners fired on context " << *ctx << endmsg;
      while ( incs->second.try_pop( inc ) ) {
        std::vector<IIncidentListener*> ls;
        getListeners( ls, inc->type() );
        p.incidents.emplace_back( std::move( inc ) );
        p.listeners.emplace_back( std::move( ls ) );
      }
    }
  }
  return p;
}

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

override

Definition at line 246 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 157 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 55 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 sc;
}

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

override

Definition at line 137 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 119 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 91 of file IncidentSvc.h.

tbb::concurrent_unordered_map<EventContext, IncQueue_t, EventContextHash, EventContextHash> IncidentSvc::m_firedIncidents

private

Definition at line 103 of file IncidentSvc.h.

ListenerMap IncidentSvc::m_listenerMap

private

List of auditor names.

Definition at line 87 of file IncidentSvc.h.

std::recursive_mutex IncidentSvc::m_listenerMapMutex

mutableprivate

Mutex to synchronize access to m_listenerMap.

Definition at line 94 of file IncidentSvc.h.

ChronoEntity IncidentSvc::m_timer

mutableprivate

timer & it's lock

Definition at line 97 of file IncidentSvc.h.

bool IncidentSvc::m_timerLock = false

mutableprivate

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