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...
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...
	~extends () override=default
	Virtual destructor. 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 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 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, std::unique_ptr< Mutex_t > >	m_lockMap

Additional Inherited Members
Protected Member Functions inherited from CommonMessaging< implements< IComponentManager > >
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...

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 36 of file ServiceManager.h.

Member Typedef Documentation

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

Definition at line 50 of file ServiceManager.h.

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

private

Definition at line 182 of file ServiceManager.h.

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

Definition at line 51 of file ServiceManager.h.

typedef boost::recursive_mutex ServiceManager::Mutex_t

private

Mutex to synchronize shared service initialization between threads.

Definition at line 181 of file ServiceManager.h.

Constructor & Destructor Documentation

ServiceManager::ServiceManager

(

IInterface *

application

)

default creator

Definition at line 42 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 ( )

override

virtual destructor

Definition at line 52 of file ServiceManager.cpp.

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

Member Function Documentation

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

override

implementation of ISvcManager::addService

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

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

override

implementation of ISvcManager::addService

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

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 59 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);
  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...
}

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

override

implementation of ISvcManager::declareSvcType

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

void ServiceManager::dump ( ) const

private

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

}

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

override

implementation of ISvcLocation::existsService

Definition at line 228 of file ServiceManager.cpp.

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

StatusCode ServiceManager::finalize ( )

override

Finalize (from INITIALIZED to CONFIGURED).

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

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

inlineprivate

Definition at line 133 of file ServiceManager.h.

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

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

inlineprivate

Definition at line 138 of file ServiceManager.h.

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

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

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(), ptr );
  }

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

inlineprivate

Definition at line 148 of file ServiceManager.h.

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

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

override

manage priorities of services

Definition at line 498 of file ServiceManager.cpp.

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

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

override

Return the list of Services.

Definition at line 215 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 const_cast<IService*>(i.service.get());
  });
  return m_listOfPtrs;
}

StatusCode ServiceManager::initialize ( )

override

Initialization (from CONFIGURED to INITIALIZED).

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

bool ServiceManager::loopCheckEnabled ( ) const

override

Get the value of the initialization loop check flag.

Definition at line 517 of file ServiceManager.cpp.

                                            {
  return m_loopCheck;
}

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

inlineoverride

Return the name of the manager (implementation of INamedInterface)

Definition at line 111 of file ServiceManager.h.

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

StatusCode ServiceManager::reinitialize ( )

override

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

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

StatusCode ServiceManager::removeService ( IService *  svc )

override

implementation of ISvcManager::removeService

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

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

override

implementation of ISvcManager::removeService

Definition at line 245 of file ServiceManager.cpp.

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

StatusCode ServiceManager::restart ( )

override

Initialization (from RUNNING to RUNNING, via INITIALIZED).

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

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

override

Returns a smart pointer to a service.

Definition at line 161 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(name, std::unique_ptr<Mutex_t>( new Mutex_t )).first;
    }
    imut = mit->second.get();
  }

  {
    // 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;
}
}

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 122 of file ServiceManager.h.

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

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

inlineoverride

Function needed by CommonMessaging.

Definition at line 57 of file ServiceManager.h.

{ return m_svcLocator; }

void ServiceManager::setLoopCheckEnabled ( bool  en )

override

Set the value of the initialization loop check flag.

Definition at line 523 of file ServiceManager.cpp.

                                                {
  m_loopCheck = en;
}

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

override

Definition at line 506 of file ServiceManager.cpp.

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

StatusCode ServiceManager::start ( )

override

Start (from INITIALIZED to RUNNING).

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

StatusCode ServiceManager::stop ( )

override

Stop (from RUNNING to INITIALIZED).

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

SmartIF<IService> ServiceManager::m_appSvc

private

Pointer to the application IService interface.

Definition at line 173 of file ServiceManager.h.

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

private

Definition at line 178 of file ServiceManager.h.

Mutex_t ServiceManager::m_gLock

mutableprivate

Definition at line 184 of file ServiceManager.h.

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

mutableprivate

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

Definition at line 176 of file ServiceManager.h.

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 155 of file ServiceManager.h.

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

mutableprivate

Definition at line 185 of file ServiceManager.h.

bool ServiceManager::m_loopCheck = true

private

Check for service initialization loops.

Definition at line 170 of file ServiceManager.h.

MapType ServiceManager::m_maptype

private

Map of service name and service type.

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