ServiceManager Class Reference

The ServiceManager class is in charge of the creation of concrete instances of Services. More...

#include <src/ApplicationMgr/ServiceManager.h>

Inheritance diagram for ServiceManager:

Collaboration diagram for ServiceManager:

Classes
struct	ServiceItem

Public Types
typedef std::list< ServiceItem >	ListSvc
typedef GaudiUtils::Map< std::string, std::string >	MapType
Public Types inherited from extends< ComponentManager, ISvcManager, ISvcLocator >
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 CommonMessaging< implements< IComponentManager > >
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...

Public Member Functions
	ServiceManager (IInterface *application)
	default creator More...
SmartIF< ISvcLocator > &	serviceLocator () const override
	Function needed by CommonMessaging. More...
	~ServiceManager () override
	virtual destructor More...
const std::list< IService * > &	getServices () const override
	Return the list of Services. More...
bool	existsService (const std::string &name) const override
	implementation of ISvcLocation::existsService More...
StatusCode	addService (IService *svc, int prio=DEFAULT_SVC_PRIORITY) override
	implementation of ISvcManager::addService More...
StatusCode	addService (const Gaudi::Utils::TypeNameString &typeName, int prio=DEFAULT_SVC_PRIORITY) override
	implementation of ISvcManager::addService More...
StatusCode	removeService (IService *svc) override
	implementation of ISvcManager::removeService More...
StatusCode	removeService (const std::string &name) override
	implementation of ISvcManager::removeService More...
StatusCode	declareSvcType (const std::string &svcname, const std::string &svctype) override
	implementation of ISvcManager::declareSvcType More...
SmartIF< IService > &	createService (const Gaudi::Utils::TypeNameString &nametype) override
	implementation of ISvcManager::createService NOTE: as this returns a &, we must guarantee that once created, these SmartIF remain pinned in their location, thus constraining the underlying implementation... More...
StatusCode	initialize () override
	Initialization (from CONFIGURED to INITIALIZED). More...
StatusCode	start () override
	Start (from INITIALIZED to RUNNING). More...
StatusCode	stop () override
	Stop (from RUNNING to INITIALIZED). More...
StatusCode	finalize () override
	Finalize (from INITIALIZED to CONFIGURED). More...
StatusCode	reinitialize () override
	Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED). More...
StatusCode	restart () override
	Initialization (from RUNNING to RUNNING, via INITIALIZED). More...
int	getPriority (const std::string &name) const override
	manage priorities of services More...
StatusCode	setPriority (const std::string &name, int pri) override
bool	loopCheckEnabled () const override
	Get the value of the initialization loop check flag. More...
void	setLoopCheckEnabled (bool en) override
	Set the value of the initialization loop check flag. More...
const std::string &	name () const override
	Return the name of the manager (implementation of INamedInterface) More...
SmartIF< IService > &	service (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override
	Returns a smart pointer to a service. More...
template<typename T >
SmartIF< T >	service (const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true)
	Returns a smart pointer to the requested interface of a service. More...
void	outputLevelUpdate () override
	Function to call to update the outputLevel of the components (after a change in MessageSvc). More...
virtual StatusCode	addService (IService *svc, int prio=DEFAULT_SVC_PRIORITY)=0
	Add a service to the "active" list of services of the factory. More...
virtual StatusCode	addService (const std::string &typ, const std::string &nam, int prio)
	Add a service to the "active" list of services of the factory. More...
virtual StatusCode	addService (const Gaudi::Utils::TypeNameString &nametype, int prio=DEFAULT_SVC_PRIORITY)=0
	Add a service to the "active" list of services of the factory. More...
virtual SmartIF< IService > &	createService (const Gaudi::Utils::TypeNameString &nametype)=0
	Creates and instance of a service type that has been declared beforehand and assigns it a name. More...
virtual StatusCode	createService (const std::string &svctype, const std::string &svcname, IService *&svc)
	Creates and instance of a service type that has been declared beforehand and assigns it a name. More...
Public Member Functions inherited from extends< ComponentManager, ISvcManager, ISvcLocator >
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 ComponentManager
	ComponentManager (IInterface *application, const InterfaceID &baseIID)
	Constructor. More...
const InterfaceID &	componentBaseInterface () const override
	Basic interface id of the managed components. More...
StatusCode	queryInterface (const InterfaceID &iid, void **pinterface) override
	Specialized queryInterface implementation. More...
SmartIF< ISvcLocator > &	serviceLocator () const override
StatusCode	configure () override
	Configuration (from OFFLINE to CONFIGURED). More...
StatusCode	initialize () override
	Initialization (from CONFIGURED to INITIALIZED). More...
StatusCode	start () override
	Start (from INITIALIZED to RUNNING). More...
StatusCode	stop () override
	Stop (from RUNNING to INITIALIZED). More...
StatusCode	finalize () override
	Finalize (from INITIALIZED to CONFIGURED). More...
StatusCode	terminate () override
	Initialization (from CONFIGURED to OFFLINE). More...
StatusCode	reinitialize () override
	Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED). More...
StatusCode	restart () override
	Initialization (from RUNNING to RUNNING, via INITIALIZED). More...
Gaudi::StateMachine::State	FSMState () const override
	Get the current state. More...
Gaudi::StateMachine::State	targetFSMState () const override
	When we are in the middle of a transition, get the state where the transition is leading us. More...
Public Member Functions inherited from CommonMessaging< implements< IComponentManager > >
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 boost::recursive_mutex	Mutex_t
	Mutex to synchronize shared service initialization between threads. More...
typedef boost::lock_guard< Mutex_t >	LockGuard_t

Private Member Functions
ListSvc::iterator	find (const std::string &name)
ListSvc::const_iterator	find (const std::string &name) const
ListSvc::iterator	find (const IService *ptr)
ListSvc::const_iterator	find (const IService *ptr) const
void	dump () const

Private Attributes
ListSvc	m_listsvc
	List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because there can be SmartIF<T>& 'out there' that refer to these specific SmarIF<T>, we unfortunately must guarantee that they never move after creation. More...
MapType	m_maptype
	Map of service name and service type. More...
bool	m_loopCheck = true
	Check for service initialization loops. More...
SmartIF< IService >	m_appSvc
	Pointer to the application IService interface. More...
std::list< IService * >	m_listOfPtrs
	List of pointers to the know services used to implement getServices() More...
GaudiUtils::Map< InterfaceID, SmartIF< IInterface > >	m_defaultImplementations
Mutex_t	m_gLock
std::map< std::string, Mutex_t >	m_lockMap

Additional Inherited Members
Protected Member Functions inherited from CommonMessaging< implements< IComponentManager > >
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 ComponentManager
SmartIF< IInterface >	m_application
	Pointer to the owner of the manager. More...
SmartIF< IStateful >	m_stateful
	Pointer to the IStateful interface of the owner. More...
InterfaceID	m_basicInterfaceId
	Basic interface id of the managed components. More...
SmartIF< ISvcLocator >	m_svcLocator
	Service locator (needed to access the MessageSvc) More...
friend	ApplicationMgr

Detailed Description

The ServiceManager class is in charge of the creation of concrete instances of Services.

The ApplicationMgr delegates the creation and bookkeeping of services to the ServiceManager. In order to be able to create services from which it is not know the concrete type it requires that the services has been declared in one of 3 possible ways: an abstract static creator function, a dynamic link library or an abstract factory reference.

Author

Pere Mato

Definition at line 46 of file ServiceManager.h.

Member Typedef Documentation

ListSvc

typedef std::list<ServiceItem> ServiceManager::ListSvc

Definition at line 59 of file ServiceManager.h.

LockGuard_t

typedef boost::lock_guard<Mutex_t> ServiceManager::LockGuard_t

private

Definition at line 188 of file ServiceManager.h.

MapType

typedef GaudiUtils::Map<std::string, std::string> ServiceManager::MapType

Definition at line 60 of file ServiceManager.h.

Mutex_t

typedef boost::recursive_mutex ServiceManager::Mutex_t

private

Mutex to synchronize shared service initialization between threads.

Definition at line 187 of file ServiceManager.h.

Constructor & Destructor Documentation

ServiceManager()

ServiceManager::ServiceManager

(

IInterface *

application

)

default creator

Definition at line 53 of file ServiceManager.cpp.

    : base_class( application, IService::interfaceID() ), m_appSvc( application ) {
  // Set the service locator to myself
  m_svcLocator = this;
  addRef(); // increase ref count, so we live forever...
}

~ServiceManager()

ServiceManager::~ServiceManager ( )

override

virtual destructor

Definition at line 61 of file ServiceManager.cpp.

                                {
  //-- inform the orphan services that I am gone....
  for ( auto& svc : m_listsvc ) svc.service->setServiceManager( nullptr );
}

Member Function Documentation

addService() [1/5]

StatusCode ServiceManager::addService ( IService *  svc, int  prio = DEFAULT_SVC_PRIORITY  )

override

implementation of ISvcManager::addService

Definition at line 110 of file ServiceManager.cpp.

{
  ListSvc::iterator it = find( svc );
  LockGuard_t       lck( m_gLock );
  if ( it != m_listsvc.end() ) {
    it->priority = prio; // if the service is already known, it is equivalent to a setPriority
    it->active   = true; // and make it active
  } else {
    m_listsvc.emplace_back( svc, prio, true );
  }
  return StatusCode::SUCCESS;
}

addService() [2/5]

StatusCode ServiceManager::addService ( const Gaudi::Utils::TypeNameString &  typeName, int  prio = DEFAULT_SVC_PRIORITY  )

override

implementation of ISvcManager::addService

Definition at line 126 of file ServiceManager.cpp.

{
  auto it = find( typeName.name() ); // try to find the service by name
  if ( it == m_listsvc.end() ) {     // not found
    // If the service does not exist, we create it
    SmartIF<IService>& svc =
        createService( typeName ); // WARNING: svc is now a reference to something that lives in m_listsvc
    if ( !svc ) return StatusCode::FAILURE;
    it            = find( svc.get() ); // now it is in the list because createService added it
    it->priority  = prio;
    StatusCode sc = StatusCode( StatusCode::SUCCESS, true );
    if ( targetFSMState() >= Gaudi::StateMachine::INITIALIZED ) { // WARNING: this can trigger a recursion!!!
      sc = svc->sysInitialize();
      if ( sc.isSuccess() && targetFSMState() >= Gaudi::StateMachine::RUNNING ) { sc = svc->sysStart(); }
    }
    if ( sc.isFailure() ) { // if initialization failed, remove it from the list
      error() << "Unable to initialize service \"" << typeName.name() << "\"" << endmsg;
      LockGuard_t lck( m_gLock );
      m_listsvc.erase( it );
      // Note: removing it from the list + the SmartIF going out of scope should trigger the delete
      // delete svc.get();
      return sc;
    }
    // initialization successful, we can work with the service
    // Move the just initialized service to the back of the list
    // (we care more about order of initialization than of creation)
    LockGuard_t lck( m_gLock );
    m_listsvc.push_back( *it );
    m_listsvc.erase( it );
    it = std::prev( std::end( m_listsvc ) ); // last entry (the iterator was invalidated by erase)
  } else {
    // if the service is already known, it is equivalent to a setPriority
    it->priority = prio;
  }
  // 'it' is defined because either we found the service or we created it
  // Now we can activate the service
  it->active = true; // and make it active
  return StatusCode( StatusCode::SUCCESS, true );
}

addService() [3/5]

virtual StatusCode ISvcManager::addService

Add a service to the "active" list of services of the factory.

Parameters

svc	Pointer to the service

Returns

StatusCode indicating success or failure.

addService() [4/5]

virtual StatusCode ISvcManager::addService

inline

Add a service to the "active" list of services of the factory.

Parameters

svc	Pointer to the service

Returns

StatusCode indicating success or failure.

Definition at line 58 of file ISvcManager.h.

                                                                                        {
    return addService( Gaudi::Utils::TypeNameString( nam, typ ), prio );
  }

addService() [5/5]

virtual StatusCode ISvcManager::addService

Add a service to the "active" list of services of the factory.

Parameters

svc	Pointer to the service

Returns

StatusCode indicating success or failure.

createService() [1/3]

SmartIF< IService > & ServiceManager::createService ( const Gaudi::Utils::TypeNameString &  nametype )

override

implementation of ISvcManager::createService NOTE: as this returns a &, we must guarantee that once created, these SmartIF remain pinned in their location, thus constraining the underlying implementation...

Fix-Me:

: what does this mean?

Definition at line 68 of file ServiceManager.cpp.

{
  // Check if the service is already existing
  if ( existsService( typeName.name() ) ) {
    // return an error because a service with that name already exists
    return no_service;
  }

  const std::string& name = typeName.name();
  std::string        type = typeName.type();
  if ( !typeName.haveType() ) { // the type is not explicit
    // see we have some specific type mapping for the name
    auto it = m_maptype.find( typeName.name() );
    if ( it != m_maptype.end() ) {
      type = it->second; // use the declared type
    }
  }

  auto ip = type.find( "__" );
  if ( ip != std::string::npos ) type.erase( ip, type.length() );

  IService* service = Service::Factory::create( type, name, this ).release();
  if ( !service ) {
    fatal() << "No Service factory for " << type << " available." << endmsg;
    return no_service;
  }
  // Check the compatibility of the version of the interface obtained
  if ( !isValidInterface( service ) ) {
    fatal() << "Incompatible interface IService version for " << type << endmsg;
    return no_service;
  }

  m_listsvc.push_back( service );
  service->setServiceManager( this );
  return m_listsvc.back().service; // DANGER: returns a reference to a SmartIF in m_listsvc, and hence does no longer
                                   // allow relocations of those...
}

createService() [2/3]

virtual SmartIF<IService>& ISvcManager::createService

Creates and instance of a service type that has been declared beforehand and assigns it a name.

It returns a pointer to an IService.

Parameters

nametype

name/type of the service to create

Returns

SmartIF& to the created service.

NOTE: as this returns a &, the underlying implementation must guarantee that once created, these SmartIF remain pinned in their location, thus constraining the underlying implementation (i.e. one cannot use something like std::vector<SmartIF<IService>>). If this interface had used value-semantics, and returned just plain SmartIF<IService> (i.e. WITHOUT the &) then the underlying implementation would have much more freedom)

createService() [3/3]

virtual StatusCode ISvcManager::createService

inline

Creates and instance of a service type that has been declared beforehand and assigns it a name.

It returns a pointer to an IService.

Parameters

svctype	Service type name
svcname	Service name to be set
svc	Returned service pointer

Returns

StatusCode indicating success or failure.

Definition at line 131 of file ISvcManager.h.

                                                                                                         {
    SmartIF<IService> s = createService( svctype + "/" + svcname );
    svc                 = s.get();
    if ( svc ) {
      svc->addRef(); // Needed to maintain the correct reference counting.
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }

declareSvcType()

StatusCode ServiceManager::declareSvcType ( const std::string &  svcname, const std::string &  svctype  )

override

implementation of ISvcManager::declareSvcType

Definition at line 251 of file ServiceManager.cpp.

{
  // once we get to C++17, replace with m_maptype.insert_or_assign...
  auto p = m_maptype.emplace( svcname, svctype );
  if ( !p.second ) p.first->second = svctype;
  return StatusCode::SUCCESS;
}

dump()

void ServiceManager::dump ( ) const

private

Definition at line 510 of file ServiceManager.cpp.

                                {

  auto& log = info();
  log << "\n"
      << "=====================  listing all services  ===================\n"
      << " prior   ref name                           active\n";

  for ( const auto& svc : m_listsvc ) {

    log.width( 6 );
    log.flags( std::ios_base::right );
    log << svc.priority << " ";
    log.width( 5 );
    log << svc.service->refCount() << " ";
    log.width( 30 );
    log.flags( std::ios_base::left );
    log << svc.service->name() << " ";
    log.width( 2 );
    log << svc.active << std::endl;
  }

  log << "=================================================================\n";
  log << endmsg;
}

existsService()

bool ServiceManager::existsService ( const std::string &  name ) const

override

implementation of ISvcLocation::existsService

Definition at line 224 of file ServiceManager.cpp.

{
  return find( name ) != m_listsvc.end();
}

finalize()

StatusCode ServiceManager::finalize ( )

override

Finalize (from INITIALIZED to CONFIGURED).

Definition at line 404 of file ServiceManager.cpp.

{
  // make sure that HistogramDataSvc and THistSvc get finalized after the
  // ToolSvc, and the FileMgr and StatusCodeSvc after that
  int pri_tool = getPriority( "ToolSvc" );
  if ( pri_tool != 0 ) {
    setPriority( "THistSvc", pri_tool - 10 ).ignore();
    setPriority( "ChronoStatSvc", pri_tool - 20 ).ignore();
    setPriority( "AuditorSvc", pri_tool - 30 ).ignore();
    setPriority( "NTupleSvc", pri_tool - 10 ).ignore();
    setPriority( "HistogramDataSvc", pri_tool - 10 ).ignore();
    // Preserve the relative ordering between HistogramDataSvc and HistogramPersistencySvc
    setPriority( "HistogramPersistencySvc", pri_tool - 20 ).ignore();
    setPriority( "HistorySvc", pri_tool - 30 ).ignore();
    setPriority( "FileMgr", pri_tool - 40 ).ignore();
  }

  // get list of PostFinalize clients
  std::vector<IIncidentListener*> postFinList;
  auto                            p_inc = service<IIncidentSvc>( "IncidentSvc", false );
  if ( p_inc ) {
    p_inc->getListeners( postFinList, IncidentType::SvcPostFinalize );
    p_inc.reset();
  }

  // make sure the StatusCodeSvc gets finalized really late:
  setPriority( "StatusCodeSvc", -9999 ).ignore();

  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // dump();

  StatusCode sc( StatusCode::SUCCESS, true );
  {
    // we work on a copy to avoid to operate twice on the services created on demand
    // which are already in the correct state.
    // only act on active services
    // call finalize() for all services in reverse order
    for ( const auto& svc : reverse( activeSvc( m_listsvc ) ) ) {
      const std::string& name = svc->name();
      // ignore the current state for the moment
      // if( Gaudi::StateMachine::INITIALIZED == svc->state() )
      DEBMSG << "Finalizing service " << name << endmsg;
      if ( !svc->sysFinalize().isSuccess() ) {
        warning() << "Finalization of service " << name << " failed" << endmsg;
        sc = StatusCode::FAILURE;
      }
    }
  }

  // call SvcPostFinalize on all clients
  if ( !postFinList.empty() ) {
    DEBMSG << "Will call SvcPostFinalize for " << postFinList.size() << " clients" << endmsg;
    Incident inc( "ServiceManager", IncidentType::SvcPostFinalize );
    for ( auto& itr : postFinList ) itr->handle( inc );
  }

  // loop over all Active Services, removing them one by one.
  // They should be deleted because the reference counting goes to 0.
  DEBMSG << "Looping over all active services..." << endmsg;
  auto it = m_listsvc.begin();
  while ( it != m_listsvc.end() ) {
    DEBMSG << "---- " << it->service->name() << " (refCount = " << it->service->refCount() << ")" << endmsg;
    if ( it->service->refCount() < 1 ) {
      warning() << "Too low reference count for " << it->service->name() << " (should not go below 1 at this point)"
                << endmsg;
      it->service->addRef();
    }
    if ( it->active ) {
      it = m_listsvc.erase( it );
    } else {
      ++it;
    }
  }
  return sc;
}

find() [1/4]

ListSvc::iterator ServiceManager::find ( const std::string &  name )

inlineprivate

Definition at line 143 of file ServiceManager.h.

                                                       {
    boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }

find() [2/4]

ListSvc::const_iterator ServiceManager::find ( const std::string &  name ) const

inlineprivate

Definition at line 147 of file ServiceManager.h.

                                                                   {
    boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
    return std::find( m_listsvc.begin(), m_listsvc.end(), name );
  }

find() [3/4]

ListSvc::iterator ServiceManager::find ( const IService *  ptr )

inlineprivate

Definition at line 151 of file ServiceManager.h.

                                                     {
    boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
    return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
  }

find() [4/4]

ListSvc::const_iterator ServiceManager::find ( const IService *  ptr ) const

inlineprivate

Definition at line 155 of file ServiceManager.h.

                                                                 {
    boost::lock_guard<boost::recursive_mutex> lck( m_gLock );
    return std::find( m_listsvc.begin(), m_listsvc.end(), ptr );
  }

getPriority()

int ServiceManager::getPriority ( const std::string &  name ) const

override

manage priorities of services

Definition at line 483 of file ServiceManager.cpp.

                                                             {
  //------------------------------------------------------------------------------
  auto it = find( name );
  return ( it != m_listsvc.end() ) ? it->priority : 0;
}

getServices()

const std::list< IService * > & ServiceManager::getServices ( ) const

override

Return the list of Services.

Definition at line 214 of file ServiceManager.cpp.

{
  m_listOfPtrs.clear();
  std::transform( std::begin( m_listsvc ), std::end( m_listsvc ), std::back_inserter( m_listOfPtrs ),
                  []( ListSvc::const_reference i ) { return i.service.get(); } );
  return m_listOfPtrs;
}

initialize()

StatusCode ServiceManager::initialize ( )

override

Initialization (from CONFIGURED to INITIALIZED).

Definition at line 261 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.

  StatusCode sc( StatusCode::SUCCESS, true );
  // call initialize() for all services
  for ( auto& it : activeSvc( m_listsvc ) ) {
    const std::string& name = it->name();
    switch ( it->FSMState() ) {
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Service " << name << " already initialized" << endmsg;
      break;
    case Gaudi::StateMachine::OFFLINE:
      DEBMSG << "Initializing service " << name << endmsg;
      sc = it->sysInitialize();
      if ( !sc.isSuccess() ) {
        error() << "Unable to initialize Service: " << name << endmsg;
        return sc;
      }
      break;
    default:
      error() << "Service " << name << " not in the correct state to be initialized (" << it->FSMState() << ")"
              << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

loopCheckEnabled()

bool ServiceManager::loopCheckEnabled ( ) const

override

Get the value of the initialization loop check flag.

Definition at line 501 of file ServiceManager.cpp.

{ return m_loopCheck; }

name()

const std::string& ServiceManager::name ( ) const

inlineoverride

Return the name of the manager (implementation of INamedInterface)

Definition at line 120 of file ServiceManager.h.

                                         {
    static std::string _name = "ServiceManager";
    return _name;
  }

outputLevelUpdate()

void ServiceManager::outputLevelUpdate ( )

override

Function to call to update the outputLevel of the components (after a change in MessageSvc).

Definition at line 535 of file ServiceManager.cpp.

                                       {
  resetMessaging();
  for ( auto& svcItem : m_listsvc ) {
    const auto svc = dynamic_cast<Service*>( svcItem.service.get() );
    if ( svc ) svc->resetMessaging();
  }
}

reinitialize()

StatusCode ServiceManager::reinitialize ( )

override

Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

Definition at line 362 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services
  StatusCode sc( StatusCode::SUCCESS, true );
  // Re-Initialize all services
  for ( auto& svc : activeSvc( m_listsvc ) ) {
    sc = svc->sysReinitialize();
    if ( !sc.isSuccess() ) {
      error() << "Unable to re-initialize Service: " << svc->name() << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

removeService() [1/2]

StatusCode ServiceManager::removeService ( IService *  svc )

override

implementation of ISvcManager::removeService

Definition at line 231 of file ServiceManager.cpp.

{
  auto it = find( svc );
  if ( it == m_listsvc.end() ) return StatusCode( StatusCode::FAILURE, true );
  m_listsvc.erase( it );
  return StatusCode( StatusCode::SUCCESS, true );
}

removeService() [2/2]

StatusCode ServiceManager::removeService ( const std::string &  name )

override

implementation of ISvcManager::removeService

Definition at line 241 of file ServiceManager.cpp.

{
  auto it = find( name );
  if ( it == m_listsvc.end() ) return StatusCode::FAILURE;
  m_listsvc.erase( it );
  return StatusCode::SUCCESS;
}

restart()

StatusCode ServiceManager::restart ( )

override

Initialization (from RUNNING to RUNNING, via INITIALIZED).

Definition at line 383 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services
  StatusCode sc( StatusCode::SUCCESS, true );
  // Re-Start all services
  for ( auto& svc : activeSvc( m_listsvc ) ) {
    sc = svc->sysRestart();
    if ( !sc.isSuccess() ) {
      error() << "Unable to re-start Service: " << svc->name() << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

service() [1/2]

SmartIF< IService > & ServiceManager::service ( const Gaudi::Utils::TypeNameString &  typeName, const bool  createIf = true  )

override

Returns a smart pointer to a service.

Definition at line 169 of file ServiceManager.cpp.

                                                                                                          {
  const std::string& name = typeName.name();

  // Acquire the RAII lock to avoid simultaneous attempts from different threads to initialize a service

  Mutex_t* imut;
  {
    // get the global lock, then extract/create the service specific mutex
    // then release global lock

    LockGuard_t lk( m_gLock );
    auto        mit = m_lockMap.find( name );
    if ( mit == m_lockMap.end() ) {
      mit = m_lockMap.emplace( std::piecewise_construct_t{}, std::forward_as_tuple( name ), std::forward_as_tuple() )
                .first;
    }
    imut = &mit->second;
  }

  {
    // now we have the service specific lock on the above mutex
    LockGuard_t lk2( *imut );

    auto it = find( name );

    if ( it != m_listsvc.end() ) {
      if ( m_loopCheck && ( createIf && it->service->FSMState() == Gaudi::StateMachine::CONFIGURED ) ) {
        error() << "Initialization loop detected when creating service \"" << name << "\"" << endmsg;
        return no_service;
      }
      return it->service;
    }

    // Service not found. The user may be interested in one of the interfaces
    // of the application manager itself
    if ( name == "ApplicationMgr" || name == "APPMGR" || name == "" ) { return m_appSvc; }

    // last resort: we try to create the service
    if ( createIf && addService( typeName ).isSuccess() ) { return find( name )->service; }

    return no_service;
  }
}

service() [2/2]

template<typename T >

SmartIF<T> ServiceManager::service ( const Gaudi::Utils::TypeNameString &  typeName, const bool  createIf = true  )

inline

Returns a smart pointer to the requested interface of a service.

Definition at line 130 of file ServiceManager.h.

                                                                                                    {
    return SmartIF<T>{service( typeName, createIf )};
  }

serviceLocator()

SmartIF<ISvcLocator>& ServiceManager::serviceLocator ( ) const

inlineoverride

Function needed by CommonMessaging.

Definition at line 66 of file ServiceManager.h.

{ return m_svcLocator; }

setLoopCheckEnabled()

void ServiceManager::setLoopCheckEnabled ( bool  en )

override

Set the value of the initialization loop check flag.

Definition at line 505 of file ServiceManager.cpp.

{ m_loopCheck = en; }

setPriority()

StatusCode ServiceManager::setPriority ( const std::string &  name, int  pri  )

override

Definition at line 490 of file ServiceManager.cpp.

                                                                        {
  //------------------------------------------------------------------------------
  auto it = find( name );
  if ( it == m_listsvc.end() ) return StatusCode::FAILURE;
  it->priority = prio;
  return StatusCode::SUCCESS;
}

start()

StatusCode ServiceManager::start ( )

override

Start (from INITIALIZED to RUNNING).

Definition at line 295 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // (which are already in the correct state.
  // only act on active services
  StatusCode sc( StatusCode::SUCCESS, true );
  // call initialize() for all services
  for ( auto& it : activeSvc( m_listsvc ) ) {
    const std::string& name = it->name();
    switch ( it->FSMState() ) {
    case Gaudi::StateMachine::RUNNING:
      DEBMSG << "Service " << name << " already started" << endmsg;
      break;
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Starting service " << name << endmsg;
      sc = it->sysStart();
      if ( !sc.isSuccess() ) {
        error() << "Unable to start Service: " << name << endmsg;
        return sc;
      }
      break;
    default:
      error() << "Service " << name << " not in the correct state to be started (" << it->FSMState() << ")" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

stop()

StatusCode ServiceManager::stop ( )

override

Stop (from RUNNING to INITIALIZED).

Definition at line 328 of file ServiceManager.cpp.

{
  // ensure that the list is ordered by priority
  m_listsvc.sort();
  // we work on a copy to avoid to operate twice on the services created on demand
  // which are already in the correct state.
  // only act on active services

  StatusCode sc( StatusCode::SUCCESS, true );
  // call stop() for all services
  for ( const auto& svc : reverse( activeSvc( m_listsvc ) ) ) {
    const std::string& name = svc->name();
    switch ( svc->FSMState() ) {
    case Gaudi::StateMachine::INITIALIZED:
      DEBMSG << "Service " << name << " already stopped" << endmsg;
      break;
    case Gaudi::StateMachine::RUNNING:
      DEBMSG << "Stopping service " << name << endmsg;
      sc = svc->sysStop();
      if ( !sc.isSuccess() ) {
        error() << "Unable to stop Service: " << name << endmsg;
        return sc;
      }
      break;
    default:
      DEBMSG << "Service " << name << " not in the correct state to be stopped (" << svc->FSMState() << ")" << endmsg;
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_appSvc

SmartIF<IService> ServiceManager::m_appSvc

private

Pointer to the application IService interface.

Definition at line 179 of file ServiceManager.h.

m_defaultImplementations

GaudiUtils::Map<InterfaceID, SmartIF<IInterface> > ServiceManager::m_defaultImplementations

private

Definition at line 184 of file ServiceManager.h.

m_gLock

Mutex_t ServiceManager::m_gLock

mutableprivate

Definition at line 190 of file ServiceManager.h.

m_listOfPtrs

std::list<IService*> ServiceManager::m_listOfPtrs

mutableprivate

List of pointers to the know services used to implement getServices()

Definition at line 182 of file ServiceManager.h.

m_listsvc

ListSvc ServiceManager::m_listsvc

private

List of service maintained by ServiceManager This contains SmartIF<T> for all services – and because there can be SmartIF<T>& 'out there' that refer to these specific SmarIF<T>, we unfortunately must guarantee that they never move after creation.

Hence, we cannot use a plain std::vector here, as that may cause relocation and/or swapping of SmartIF<T>'s, and then the already handed out references may refer to the wrong item.... Note that we could use an std::vector<std::unique_ptr<ServiceItem>> (sometimes known as 'stable vector') as then the individual ServiceItems would stay pinned in their original location, but that would put ServiceItem on the heap... And maybe I'm way too paranoid...

Definition at line 161 of file ServiceManager.h.

m_lockMap

std::map<std::string, Mutex_t> ServiceManager::m_lockMap

mutableprivate

Definition at line 191 of file ServiceManager.h.

m_loopCheck

bool ServiceManager::m_loopCheck = true

private

Check for service initialization loops.

Definition at line 176 of file ServiceManager.h.

m_maptype

MapType ServiceManager::m_maptype

private

Map of service name and service type.

Definition at line 175 of file ServiceManager.h.

---

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

• GaudiCoreSvc/src/ApplicationMgr/ServiceManager.h
• GaudiCoreSvc/src/ApplicationMgr/ServiceManager.cpp