| The Gaudi Framework v29r1 (5cd95fa2)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

ApplicationMgr.cpp
Go to the documentation of this file.
1 // Include files
2 #include "ApplicationMgr.h"
3 #include "AlgorithmManager.h"
4 #include "DLLClassManager.h"
5 #include "ServiceManager.h"
6
7 #include "GaudiKernel/IJobOptionsSvc.h"
8 #include "GaudiKernel/IMessageSvc.h"
9 #include "GaudiKernel/IRunable.h"
10 #include "GaudiKernel/IService.h"
11 #include "GaudiKernel/TypeNameString.h"
12
13 #include "GaudiKernel/MsgStream.h"
14 #include "GaudiKernel/ObjectFactory.h"
15 #include "GaudiKernel/SmartIF.h"
16
17 #include "GaudiKernel/GaudiException.h"
18 #include "GaudiKernel/ThreadGaudi.h"
19
20 #include "GaudiKernel/StatusCode.h"
21 #include "GaudiKernel/System.h"
22 #include "GaudiKernel/Time.h"
23
24 #include "GaudiCoreSvcVersion.h"
25
26 using System::getEnv;
27 using System::isEnvSet;
28
29 #include <algorithm>
30 #include <cassert>
31 #include <ctime>
32 #include <limits>
33
34 #define ON_DEBUG if ( UNLIKELY( m_outputLevel <= MSG::DEBUG ) )
35 #define ON_VERBOSE if ( UNLIKELY( m_outputLevel <= MSG::VERBOSE ) )
36
37 DECLARE_OBJECT_FACTORY( ApplicationMgr )
38
39 // Implementation class for the Application Manager. In this way the
40 // ApplicationMgr class is a fully insulated concrete class. Clients
41 // (main programs) will not need to re-compile if there are changes
42 // in the implementation
43
44 //=======================================================================
45 // Constructor
46 //=======================================================================
47 ApplicationMgr::ApplicationMgr( IInterface* )
48 {
49 // IInterface initialization
50 addRef(); // Initial count set to 1
51
52 // Instantiate component managers
53 m_managers[IService::interfaceID().id()] = new ServiceManager( this );
54
55 m_svcLocator = svcManager();
56
57 // Instantiate internal services
58 // SvcLocator/Factory HAS to be already instantiated
59 m_classManager = new DLLClassManager( this );
60
61 AlgorithmManager* algMgr = new AlgorithmManager( this );
62 m_managers[IAlgorithm::interfaceID().id()] = algMgr;
63 // m_managers[IAlgorithm::interfaceID().id()] = new HiveAlgorithmManager(this);
64
65 // This property is not hosted in the ApplicationMgr instance
66 declareProperty( "AlgTypeAliases", algMgr->typeAliases(),
67 "Aliases of algorithm types, to replace an algorithm type for every instance" );
68
69 // Add action handlers to the appropriate properties
70 m_SIGo.declareUpdateHandler( &ApplicationMgr::SIGoHandler, this );
71 m_SIExit.declareUpdateHandler( &ApplicationMgr::SIExitHandler, this );
72 m_topAlgNameList.declareUpdateHandler( &ApplicationMgr::evtLoopPropertyHandler, this );
73 m_outStreamNameList.declareUpdateHandler( &ApplicationMgr::evtLoopPropertyHandler, this );
74 m_outStreamType.declareUpdateHandler( &ApplicationMgr::evtLoopPropertyHandler, this );
75 m_pluginDebugLevel.declareUpdateHandler( &ApplicationMgr::pluginDebugPropertyHandler, this );
76 // ServiceMgr Initialization loop checking
77 m_loopCheck.declareUpdateHandler( &ApplicationMgr::initLoopCheckHndlr, this );
78 svcManager()->setLoopCheckEnabled( m_loopCheck );
79
80 m_svcMapping = {"EvtDataSvc/EventDataSvc",
81 "DetDataSvc/DetectorDataSvc",
82 "HistogramSvc/HistogramDataSvc",
83 "HbookCnv::PersSvc/HbookHistSvc",
84 "RootHistCnv::PersSvc/RootHistSvc",
85 "EvtPersistencySvc/EventPersistencySvc",
86 "DetPersistencySvc/DetectorPersistencySvc",
87 "HistogramPersistencySvc/HistogramPersistencySvc"};
88 }
89
90 //============================================================================
91 // IInterface implementation: queryInterface::addRef()
92 //============================================================================
93 StatusCode ApplicationMgr::queryInterface( const InterfaceID& iid, void** ppvi )
94 {
95 if ( !ppvi ) {
96 return StatusCode::FAILURE;
97 }
98
99 // try to find own/direct interfaces:
100 StatusCode sc = base_class::queryInterface( iid, ppvi );
101 if ( sc.isSuccess() ) return sc;
102
103 // find indirect interfaces :
104 if ( ISvcLocator::interfaceID().versionMatch( iid ) ) {
105 return serviceLocator()->queryInterface( iid, ppvi );
106 }
107 if ( ISvcManager::interfaceID().versionMatch( iid ) ) {
108 return svcManager()->queryInterface( iid, ppvi );
109 }
110 if ( IAlgManager::interfaceID().versionMatch( iid ) ) {
111 return algManager()->queryInterface( iid, ppvi );
112 }
113 if ( IClassManager::interfaceID().versionMatch( iid ) ) {
114 return m_classManager->queryInterface( iid, ppvi );
115 }
116 if ( IMessageSvc::interfaceID().versionMatch( iid ) ) {
117 *ppvi = reinterpret_cast<void*>( m_messageSvc.get() );
118 if ( m_messageSvc ) m_messageSvc->addRef();
119 // Note that 0 can be a valid IMessageSvc pointer value (when used for
120 // MsgStream).
121 return StatusCode::SUCCESS;
122 }
123 *ppvi = nullptr;
124 return StatusCode::FAILURE;
125 }
126
127 //============================================================================
128 // ApplicationMgr::i_startup()
129 //============================================================================
130 StatusCode ApplicationMgr::i_startup()
131 {
132
133 StatusCode sc;
134
135 // declare factories in current module
136 m_classManager->loadModule( "" ).ignore();
137
138 // Note: we cannot use CommonMessaging methods here because MessageSvc is not there yet
139 MsgStream log( nullptr, name() );
140
141 // Create the Message service
142 auto msgsvc = svcManager()->createService( Gaudi::Utils::TypeNameString( "MessageSvc", m_messageSvcType ) );
143 if ( !msgsvc ) {
144 log << MSG::FATAL << "Error creating MessageSvc of type " << m_messageSvcType << endmsg;
145 return StatusCode::FAILURE;
146 }
147 // Get the useful interface from Message services
148 m_messageSvc = m_svcLocator->service( "MessageSvc" );
149 if ( !m_messageSvc ) {
150 log << MSG::FATAL << "Error retrieving MessageSvc." << endmsg;
151 return StatusCode::FAILURE;
152 }
153
154 auto jobsvc = svcManager()->createService( Gaudi::Utils::TypeNameString( "JobOptionsSvc", m_jobOptionsSvcType ) );
155 // Create the Job Options service
156 if ( !jobsvc ) {
157 log << MSG::FATAL << "Error creating JobOptionsSvc" << endmsg;
158 return StatusCode::FAILURE;
159 }
160 // Get the useful interface from Message services
161 m_jobOptionsSvc = m_svcLocator->service( "JobOptionsSvc" );
162 if ( !m_jobOptionsSvc ) {
163 log << MSG::FATAL << "Error retrieving JobOptionsSvc." << endmsg;
164 return StatusCode::FAILURE;
165 }
166
167 auto jobOptsIProp = jobsvc.as<IProperty>();
168 if ( !jobOptsIProp ) {
169 log << MSG::FATAL << "Error locating JobOptionsSvc" << endmsg;
170 return StatusCode::FAILURE;
171 }
172 sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "TYPE", m_jobOptionsType ) );
173 if ( !sc.isSuccess() ) {
174 log << MSG::FATAL << "Error setting TYPE option in JobOptionsSvc" << endmsg;
175 return sc;
176 }
177
178 if ( !m_jobOptionsPreAction.empty() ) {
179 sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PYTHONPARAMS", m_jobOptionsPreAction ) );
180 if ( !sc.isSuccess() ) {
181 log << MSG::FATAL << "Error setting JobOptionsPreAction option in JobOptionsSvc" << endmsg;
182 return sc;
183 }
184 }
185
186 if ( !m_jobOptionsPostAction.empty() ) {
187 sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PYTHONACTION", m_jobOptionsPostAction ) );
188 if ( !sc.isSuccess() ) {
189 log << MSG::FATAL << "Error setting JobOptionsPostAction option in JobOptionsSvc" << endmsg;
190 return sc;
191 }
192 }
193
194 if ( !m_jobOptionsPath.empty() ) { // The command line takes precedence
195 sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PATH", m_jobOptionsPath ) );
196 if ( !sc.isSuccess() ) {
197 log << MSG::FATAL << "Error setting PATH option in JobOptionsSvc" << endmsg;
198 return sc;
199 }
200 } else if ( isEnvSet( "JOBOPTPATH" ) ) { // Otherwise the Environment JOBOPTPATH
201 sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PATH", getEnv( "JOBOPTPATH" ) ) );
202 if ( !sc.isSuccess() ) {
203 log << MSG::FATAL << "Error setting PATH option in JobOptionsSvc from env" << endmsg;
204 return sc;
205 }
206 } else { // Otherwise the default
207 sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PATH", "../options/job.opts" ) );
208 if ( !sc.isSuccess() ) {
209 log << MSG::FATAL << "Error setting PATH option in JobOptionsSvc to default" << endmsg;
210 return sc;
211 }
212 }
213 jobOptsIProp.reset();
214
215 // Sets my default the Output Level of the Message service to be
216 // the same as this
217 auto msgSvcIProp = msgsvc.as<IProperty>();
218 msgSvcIProp->setProperty( Gaudi::Property<int>( "OutputLevel", m_outputLevel ) ).ignore();
219 msgSvcIProp.reset();
220
221 sc = jobsvc->sysInitialize();
222 if ( !sc.isSuccess() ) {
223 log << MSG::FATAL << "Error initializing JobOptionsSvc" << endmsg;
224 return sc;
225 }
226 sc = msgsvc->sysInitialize();
227 if ( !sc.isSuccess() ) {
228 log << MSG::FATAL << "Error initializing MessageSvc" << endmsg;
229 return sc;
230 }
231
232 // Make sure output level caches are up to date.
233 outputLevelUpdate();
234
235 return sc;
236 }
237
238 //============================================================================
239 // IAppMgrUI implementation: ApplicationMgr::configure()
240 //============================================================================
241 StatusCode ApplicationMgr::configure()
242 {
243
244 // Check if the state is compatible with the transition
245 MsgStream tlog( m_messageSvc, name() );
246 if ( Gaudi::StateMachine::CONFIGURED == m_state ) {
247 tlog << MSG::INFO << "Already Configured" << endmsg;
248 return StatusCode::SUCCESS;
249 }
250 if ( Gaudi::StateMachine::OFFLINE != m_state ) {
251 tlog << MSG::FATAL << "configure: Invalid state \"" << m_state << "\"" << endmsg;
252 return StatusCode::FAILURE;
253 }
254 m_targetState = Gaudi::StateMachine::CONFIGURED;
255
256 // Reset application return code.
257 m_returnCode = Gaudi::ReturnCode::Success;
258
259 StatusCode sc;
260 sc = i_startup();
261 if ( !sc.isSuccess() ) {
262 return sc;
263 }
264
265 MsgStream log( m_messageSvc, name() );
266
267 // Get my own options using the Job options service
268 if ( log.level() <= MSG::DEBUG ) log << MSG::DEBUG << "Getting my own properties" << endmsg;
269 sc = m_jobOptionsSvc->setMyProperties( name(), this );
270 if ( !sc.isSuccess() ) {
271 log << MSG::WARNING << "Problems getting my properties from JobOptionsSvc" << endmsg;
272 return sc;
273 }
274
275 // Check current outputLevel to eventually inform the MessageSvc
276 if ( m_outputLevel != MSG::NIL && !m_appName.empty() ) {
277 assert( m_messageSvc );
278 m_messageSvc->setOutputLevel( name(), m_outputLevel );
279 // Print a welcome message
280 log << MSG::ALWAYS << std::endl
281 << "=================================================================="
282 << "==================================================================" << std::endl
283 << " "
284 << " Welcome to " << m_appName.value();
285
286 if ( !m_appVersion.empty() ) {
287 log << MSG::ALWAYS << " version " << m_appVersion.value();
288 } else {
289 log << MSG::ALWAYS << " (GaudiCoreSvc "
290 << "v" << GAUDICORESVC_MAJOR_VERSION << "r" << GAUDICORESVC_MINOR_VERSION
291 #if GAUDICORESVC_PATCH_VERSION
292 << "p" << GAUDICORESVC_PATCH_VERSION
293 #endif
294 << ")";
295 }
296
297 // Add the host name and current time to the message
298 log << MSG::ALWAYS << std::endl
299 << " "
300 << " running on " << System::hostName() << " on " << Gaudi::Time::current().format( true ) << std::endl
301 << "=================================================================="
302 << "==================================================================" << endmsg;
303 }
304
305 // print all own properties if the options "PropertiesPrint" is set to true
306 if ( m_propertiesPrint ) {
307 const auto& properties = getProperties();
308 log << MSG::ALWAYS << "List of ALL properties of " << System::typeinfoName( typeid( *this ) ) << "/" << this->name()
309 << " #properties = " << properties.size() << endmsg;
310 for ( const auto& property : properties ) {
311 log << "Property ['Name': Value] = " << *property << endmsg;
312 }
313 }
314
315 // Check if StatusCode need to be checked
316 if ( m_codeCheck ) {
317 StatusCode::enableChecking();
318 sc = addMultiSvc( "StatusCodeSvc", -9999 );
319 if ( sc.isFailure() ) {
320 log << MSG::FATAL << "Error adding StatusCodeSvc for multiple threads" << endmsg;
321 return StatusCode::FAILURE;
322 }
323 } else {
324 StatusCode::disableChecking();
325 }
326
327 // set the requested environment variables
328 for ( auto& var : m_environment ) {
329 const std::string& name = var.first;
330 const std::string& value = var.second;
331 std::string old = System::getEnv( name.c_str() );
332 const MSG::Level lvl = ( !old.empty() && ( old != "UNKNOWN" ) ) ? MSG::WARNING : MSG::DEBUG;
333 if ( UNLIKELY( m_outputLevel <= lvl ) ) log << lvl << "Setting " << name << " = " << value << endmsg;
334 System::setEnv( name, value );
335 }
336
337 // Declare Service Types
338 for ( auto& j : m_svcMapping ) {
339 Gaudi::Utils::TypeNameString itm( j );
340 if ( declareMultiSvcType( itm.name(), itm.type() ).isFailure() ) {
341 log << MSG::ERROR << "configure: declaring svc type:'" << j << "' failed." << endmsg;
342 return StatusCode::FAILURE;
343 }
344 }
345 for ( auto& j : m_svcOptMapping ) {
346 Gaudi::Utils::TypeNameString itm( j );
347 if ( declareMultiSvcType( itm.name(), itm.type() ).isFailure() ) {
348 log << MSG::ERROR << "configure: declaring svc type:'" << j << "' failed." << endmsg;
349 return StatusCode::FAILURE;
350 }
351 }
352
353 //--------------------------------------------------------------------------
354 // Declare other Services and Algorithms by loading DLL's
355 sc = decodeDllNameList();
356 if ( sc.isFailure() ) {
357 log << MSG::ERROR << "Failure loading declared DLL's" << endmsg;
358 return sc;
359 }
360
361 //--------------------------------------------------------------------------
362 // Deal with the services explicitly declared by the user.
363 sc = decodeExtSvcNameList();
364 if ( sc.isFailure() ) {
365 log << MSG::ERROR << "Failure during external service association" << endmsg;
366 return sc;
367 }
368
369 sc = decodeMultiThreadSvcNameList();
370 if ( sc.isFailure() ) {
371 log << MSG::ERROR << "Failure during multi thread service creation" << endmsg;
372 return sc;
373 }
374
375 sc = decodeCreateSvcNameList();
376 if ( sc.isFailure() ) {
377 log << MSG::ERROR << "Failure during external service creation" << endmsg;
378 return sc;
379 }
380
381 //--------------------------------------------------------------------------
382 // Retrieve intrinsic services. If needed configure them.
383 //--------------------------------------------------------------------------
384 const Gaudi::Utils::TypeNameString evtloop_item( m_eventLoopMgr );
385 sc = addMultiSvc( evtloop_item, ServiceManager::DEFAULT_SVC_PRIORITY * 10 );
386 if ( !sc.isSuccess() ) {
387 log << MSG::FATAL << "Error adding :" << m_eventLoopMgr << endmsg;
388 return sc;
389 }
390
391 if ( m_noOfEvtThreads == 0 ) {
392 m_runable = m_svcLocator->service( m_runableType );
393 if ( !m_runable ) {
394 log << MSG::FATAL << "Error retrieving Runable: " << m_runableType.value() << "\n Check option ApplicationMgr."
395 << m_runableType.name() << endmsg;
396 return sc;
397 }
398 m_processingMgr = m_svcLocator->service( evtloop_item );
399 if ( !m_processingMgr ) {
400 log << MSG::FATAL << "Error retrieving Processing manager: " << m_eventLoopMgr.value()
401 << "\n Check option ApplicationMgr." << m_eventLoopMgr.name() << "\n No events will be processed." << endmsg;
402 return sc;
403 }
404 }
405
406 // Establish Update Handlers for ExtSvc and DLLs Properties
407 m_extSvcNameList.declareUpdateHandler( &ApplicationMgr::extSvcNameListHandler, this );
408 m_createSvcNameList.declareUpdateHandler( &ApplicationMgr::createSvcNameListHandler, this );
409 m_multiThreadSvcNameList.declareUpdateHandler( &ApplicationMgr::multiThreadSvcNameListHandler, this );
410 m_dllNameList.declareUpdateHandler( &ApplicationMgr::dllNameListHandler, this );
411
412 if ( m_actHistory ) {
413 // Create HistorySvc with a priority to ensure it's initialized last, finalized first
414 sc = svcManager()->addService( "HistorySvc", std::numeric_limits<int>::max() );
415 if ( sc.isFailure() ) {
416 log << MSG::FATAL << "Error adding HistorySvc" << endmsg;
417 return StatusCode::FAILURE;
418 }
419
420 if ( m_noOfEvtThreads > 0 ) {
421 sc = addMultiSvc( "HistorySvc", std::numeric_limits<int>::max() );
422 if ( sc.isFailure() ) {
423 log << MSG::FATAL << "Error adding HistorySvc for multiple threads" << endmsg;
424 return StatusCode::FAILURE;
425 }
426 }
427 }
428
429 log << MSG::INFO << "Application Manager Configured successfully" << endmsg;
430 m_state = m_targetState;
431 return StatusCode::SUCCESS;
432 }
433
434 //============================================================================
435 // IAppMgrUI implementation: ApplicationMgr::initialize()
436 //============================================================================
437 StatusCode ApplicationMgr::initialize()
438 {
439 StatusCode sc;
440
441 MsgStream log( m_messageSvc, name() );
442
443 // Make sure output level caches are up to date.
444 outputLevelUpdate();
445
446 // I cannot add these services in configure() because they are coming from GaudiUtils
447 // and it messes up genconf when rebuilding it.
448 if ( m_stopOnSignal ) {
449 // Instantiate the service that schedules a stop when a signal is received
450 std::string svcname( "Gaudi::Utils::StopSignalHandler" );
451 sc = svcManager()->addService( svcname );
452 if ( sc.isFailure() ) {
453 log << MSG::INFO << "Cannot instantiate " << svcname << "signals will be ignored" << endmsg;
454 }
455 }
456
457 if ( m_stalledEventMonitoring ) {
458 // Instantiate the service that schedules a stop when a signal is received
459 std::string svcname( "StalledEventMonitor" );
460 sc = svcManager()->addService( svcname );
461 if ( sc.isFailure() ) {
462 log << MSG::INFO << "Cannot instantiate " << svcname << "signals will be ignored" << endmsg;
463 }
464 }
465
466 if ( m_state == Gaudi::StateMachine::INITIALIZED ) {
467 log << MSG::INFO << "Already Initialized!" << endmsg;
468 return StatusCode::SUCCESS;
469 }
470 if ( m_state != Gaudi::StateMachine::CONFIGURED ) {
471 log << MSG::FATAL << "initialize: Invalid state \"" << m_state << "\"" << endmsg;
472 return StatusCode::FAILURE;
473 }
474 m_targetState = Gaudi::StateMachine::INITIALIZED;
475
476 //--------------------------------------------------------------------------
477 // Initialize the list of top Services
478 //--------------------------------------------------------------------------
479 sc = svcManager()->initialize();
480 if ( !sc.isSuccess() ) return sc;
481
482 //--------------------------------------------------------------------------
483 // Final steps: Inform user and change internal state
484 //--------------------------------------------------------------------------
485 log << MSG::INFO << "Application Manager Initialized successfully" << endmsg;
486 m_state = m_targetState;
487
488 return sc;
489 }
490
491 //============================================================================
492 // IAppMgrUI implementation: ApplicationMgr::start()
493 //============================================================================
494 StatusCode ApplicationMgr::start()
495 {
496
497 MsgStream log( m_messageSvc, name() );
498 StatusCode sc;
499
500 if ( m_state == Gaudi::StateMachine::RUNNING ) {
501 log << MSG::INFO << "Already Initialized!" << endmsg;
502 return StatusCode::SUCCESS;
503 }
504 if ( m_state != Gaudi::StateMachine::INITIALIZED ) {
505 log << MSG::FATAL << "start: Invalid state \"" << m_state << "\"" << endmsg;
506 return StatusCode::FAILURE;
507 }
508 m_targetState = Gaudi::StateMachine::RUNNING;
509
510 //--------------------------------------------------------------------------
511 // Initialize the list of top Services
512 //--------------------------------------------------------------------------
513 sc = svcManager()->start();
514 if ( !sc.isSuccess() ) return sc;
515
516 //--------------------------------------------------------------------------
517 // Final steps: Inform user and change internal state
518 //--------------------------------------------------------------------------
519 log << MSG::INFO << "Application Manager Started successfully" << endmsg;
520 m_state = m_targetState;
521
522 return sc;
523 }
524
525 //============================================================================
526 // IAppMgrUI implementation: ApplicationMgr::nextEvent(int)
527 //============================================================================
528 StatusCode ApplicationMgr::nextEvent( int maxevt )
529 {
530 if ( m_state != Gaudi::StateMachine::RUNNING ) {
531 MsgStream log( m_messageSvc, name() );
532 log << MSG::FATAL << "nextEvent: Invalid state \"" << m_state << "\"" << endmsg;
533 return StatusCode::FAILURE;
534 }
535 if ( !m_processingMgr ) {
536 MsgStream log( m_messageSvc, name() );
537 log << MSG::FATAL << "No event processing manager specified. Check option: " << m_eventLoopMgr.name() << endmsg;
538 return StatusCode::FAILURE;
539 }
540 return m_processingMgr->nextEvent( maxevt );
541 }
542
543 //============================================================================
544 // IAppMgrUI implementation: ApplicationMgr::stop()
545 //============================================================================
546 StatusCode ApplicationMgr::stop()
547 {
548
549 MsgStream log( m_messageSvc, name() );
550 StatusCode sc;
551
552 if ( m_state == Gaudi::StateMachine::INITIALIZED ) {
553 log << MSG::INFO << "Already Initialized!" << endmsg;
554 return StatusCode::SUCCESS;
555 }
556 if ( m_state != Gaudi::StateMachine::RUNNING ) {
557 log << MSG::FATAL << "stop: Invalid state \"" << m_state << "\"" << endmsg;
558 return StatusCode::FAILURE;
559 }
560 m_targetState = Gaudi::StateMachine::INITIALIZED;
561
562 // Stop independently managed Algorithms
563 sc = algManager()->stop();
564 if ( !sc.isSuccess() ) return sc;
565
566 //--------------------------------------------------------------------------
567 // Stop the list of top Services
568 //--------------------------------------------------------------------------
569 sc = svcManager()->stop();
570 if ( !sc.isSuccess() ) return sc;
571
572 //--------------------------------------------------------------------------
573 // Final steps: Inform user and change internal state
574 //--------------------------------------------------------------------------
575 log << MSG::INFO << "Application Manager Stopped successfully" << endmsg;
576 m_state = m_targetState;
577
578 return sc;
579 }
580
581 //============================================================================
582 // IAppMgrUI implementation: ApplicationMgr::finalize()
583 //============================================================================
584 StatusCode ApplicationMgr::finalize()
585 {
586 MsgStream log( m_messageSvc, name() );
587 if ( m_state == Gaudi::StateMachine::CONFIGURED ) {
588 log << MSG::INFO << "Already Finalized" << endmsg;
589 return StatusCode::SUCCESS;
590 }
591 if ( m_state != Gaudi::StateMachine::INITIALIZED ) {
592 log << MSG::FATAL << "finalize: Invalid state \"" << m_state << "\"" << endmsg;
593 return StatusCode::FAILURE;
594 }
595 m_targetState = Gaudi::StateMachine::CONFIGURED;
596
597 // disable message suppression in finalize
598 m_svcLocator->service<IProperty>( "MessageSvc" )
599 ->setProperty( Gaudi::Property<bool>( "enableSuppression", false ) )
600 .ignore();
601
602 // Finalize independently managed Algorithms
603 StatusCode sc = algManager()->finalize();
604 if ( sc.isFailure() ) {
605 log << MSG::WARNING << "Failed to finalize an algorithm." << endmsg;
606 m_returnCode = Gaudi::ReturnCode::FinalizationFailure;
607 }
608
609 // Finalize all Services
610 sc = svcManager()->finalize();
611 if ( sc.isFailure() ) {
612 log << MSG::WARNING << "Failed to finalize a service." << endmsg;
613 m_returnCode = Gaudi::ReturnCode::FinalizationFailure;
614 }
615
616 // svcManager()->removeService( (IService*) m_processingMgr.get() );
617 // svcManager()->removeService( (IService*) m_runable.get() );
618
619 if ( m_codeCheck ) {
620 StatusCode::disableChecking();
621 }
622
623 if ( sc.isSuccess() ) {
624 log << MSG::INFO << "Application Manager Finalized successfully" << endmsg;
625 } else {
626 log << MSG::ERROR << "Application Manager failed to finalize" << endmsg;
627 }
628
629 m_state = m_targetState;
630 return sc;
631 }
632
633 //============================================================================
634 // IAppMgrUI implementation: ApplicationMgr::terminate()
635 //============================================================================
636 StatusCode ApplicationMgr::terminate()
637 {
638 MsgStream log( m_messageSvc, name() );
639
640 if ( m_state == Gaudi::StateMachine::OFFLINE ) {
641 log << MSG::INFO << "Already Offline" << endmsg;
642 return StatusCode::SUCCESS;
643 }
644 if ( m_state != Gaudi::StateMachine::CONFIGURED ) {
645 log << MSG::FATAL << "terminate: Invalid state \"" << m_state << "\"" << endmsg;
646 return StatusCode::FAILURE;
647 }
648 // release all Services
649 m_targetState = Gaudi::StateMachine::OFFLINE;
650
651 if ( m_returnCode.value() == Gaudi::ReturnCode::Success ) {
652 log << MSG::INFO << "Application Manager Terminated successfully" << endmsg;
653 } else if ( m_returnCode.value() == Gaudi::ReturnCode::ScheduledStop ) {
654 log << MSG::INFO << "Application Manager Terminated successfully with a user requested ScheduledStop" << endmsg;
655 } else {
656 log << MSG::ERROR << "Application Manager Terminated with error code " << m_returnCode.value() << endmsg;
657 }
658
659 { // Force a disable the auditing of finalize for MessageSvc
660 auto prop = m_messageSvc.as<IProperty>();
661 if ( prop ) {
662 prop->setProperty( Gaudi::Property<bool>( "AuditFinalize", false ) ).ignore();
663 }
664 }
665 { // Force a disable the auditing of finalize for JobOptionsSvc
666 auto prop = m_jobOptionsSvc.as<IProperty>();
667 if ( prop ) {
668 prop->setProperty( Gaudi::Property<bool>( "AuditFinalize", false ) ).ignore();
669 }
670 }
671
672 // finalize MessageSvc
673 auto svc = m_messageSvc.as<IService>();
674 if ( !svc ) {
675 log << MSG::ERROR << "Could not get the IService interface of the MessageSvc" << endmsg;
676 } else {
677 svc->sysFinalize().ignore();
678 }
679
680 // finalize JobOptionsSvc
681 svc = m_jobOptionsSvc.as<IService>();
682 if ( !svc ) {
683 log << MSG::ERROR << "Could not get the IService interface of the JobOptionsSvc" << endmsg;
684 } else {
685 svc->sysFinalize().ignore();
686 }
687
688 m_state = m_targetState;
689 return StatusCode::SUCCESS;
690 }
691
692 //============================================================================
693 // Reach the required state going through all the needed transitions
694 //============================================================================
695 StatusCode ApplicationMgr::GoToState( Gaudi::StateMachine::State state, bool ignoreFailures )
696 {
697 StatusCode sc = StatusCode( StatusCode::SUCCESS, true );
698
699 switch ( state ) {
700
701 case Gaudi::StateMachine::OFFLINE:
702 switch ( m_state ) {
703 case Gaudi::StateMachine::OFFLINE:
704 return StatusCode::SUCCESS;
705 break;
706 case Gaudi::StateMachine::CONFIGURED:
707 return terminate();
708 break;
709 default: // Gaudi::StateMachine::INITIALIZED or Gaudi::StateMachine::RUNNING
710 sc = GoToState( Gaudi::StateMachine::CONFIGURED );
711 if ( sc.isSuccess() ) {
712 return terminate();
713 }
714 break;
715 }
716 break;
717
718 case Gaudi::StateMachine::CONFIGURED:
719 switch ( m_state ) {
720 case Gaudi::StateMachine::CONFIGURED:
721 return StatusCode::SUCCESS;
722 break;
723 case Gaudi::StateMachine::OFFLINE:
724 return configure();
725 break;
726 case Gaudi::StateMachine::INITIALIZED:
727 return finalize();
728 break;
729 default: // Gaudi::StateMachine::RUNNING
730 sc = GoToState( Gaudi::StateMachine::INITIALIZED );
731 if ( sc.isSuccess() ) {
732 return finalize();
733 }
734 break;
735 }
736 break;
737
738 case Gaudi::StateMachine::INITIALIZED:
739 switch ( m_state ) {
740 case Gaudi::StateMachine::INITIALIZED:
741 return StatusCode::SUCCESS;
742 break;
743 case Gaudi::StateMachine::CONFIGURED:
744 return initialize();
745 break;
746 case Gaudi::StateMachine::RUNNING:
747 return stop();
748 break;
749 default: // Gaudi::StateMachine::OFFLINE
750 sc = GoToState( Gaudi::StateMachine::CONFIGURED );
751 if ( sc.isSuccess() ) {
752 return initialize();
753 }
754 break;
755 }
756 break;
757
758 case Gaudi::StateMachine::RUNNING:
759 switch ( m_state ) {
760 case Gaudi::StateMachine::RUNNING:
761 return StatusCode::SUCCESS;
762 break;
763 case Gaudi::StateMachine::INITIALIZED:
764 return start();
765 break;
766 default: // Gaudi::StateMachine::OFFLINE or Gaudi::StateMachine::CONFIGURED
767 sc = GoToState( Gaudi::StateMachine::INITIALIZED );
768 if ( sc.isSuccess() ) {
769 return start();
770 }
771 break;
772 }
773 break;
774 }
775
776 // If I get here, there has been a problem in the recursion
777
778 if ( ignoreFailures ) {
779 // force the new state
780 m_state = state;
781 return StatusCode::SUCCESS;
782 }
783
784 return sc;
785 }
786
787 //============================================================================
788 // IAppMgrUI implementation: ApplicationMgr::run()
789 //============================================================================
790 StatusCode ApplicationMgr::run()
791 {
792 StatusCode sc = StatusCode::SUCCESS;
793
794 sc = GoToState( Gaudi::StateMachine::RUNNING );
795 if ( sc.isSuccess() ) {
796 MsgStream log( m_messageSvc, name() );
797 if ( m_runable != 0 ) { // loop over the events
798 sc = m_runable->run();
799 if ( !sc.isSuccess() ) {
800 log << MSG::FATAL << "Application execution failed. Ending the job." << endmsg;
801 }
802 } else {
803 log << MSG::FATAL << "Application has no runable object. Check option:" << m_runableType.name() << endmsg;
804 }
805 }
806 if ( sc.isSuccess() ) { // try to close cleanly
807 sc = GoToState( Gaudi::StateMachine::OFFLINE );
808 }
809 // either the runable failed of the stut-down
810 if ( sc.isFailure() ) { // try to close anyway (but keep the StatusCode unchanged)
811 GoToState( Gaudi::StateMachine::OFFLINE, true ).ignore();
812 }
813 return sc;
814 }
815
816 //============================================================================
817 // IEventProcessor implementation: executeEvent(void* par)
818 //============================================================================
819 StatusCode ApplicationMgr::executeEvent( void* par )
820 {
821 MsgStream log( m_messageSvc, name() );
822 if ( m_state == Gaudi::StateMachine::RUNNING ) {
823 if ( m_processingMgr ) {
824 return m_processingMgr->executeEvent( par );
825 }
826 }
827 log << MSG::FATAL << "executeEvent: Invalid state \"" << FSMState() << "\"" << endmsg;
828 return StatusCode::FAILURE;
829 }
830
831 //============================================================================
832 // IEventProcessor implementation: executeRun(int)
833 //============================================================================
834 StatusCode ApplicationMgr::executeRun( int evtmax )
835 {
836 MsgStream log( m_messageSvc, name() );
837 if ( m_state == Gaudi::StateMachine::RUNNING ) {
838 if ( m_processingMgr ) {
839 return m_processingMgr->executeRun( evtmax );
840 }
841 log << MSG::WARNING << "No EventLoop Manager specified " << endmsg;
842 return StatusCode::SUCCESS;
843 }
844 log << MSG::FATAL << "executeRun: Invalid state \"" << FSMState() << "\"" << endmsg;
845 return StatusCode::FAILURE;
846 }
847
848 //============================================================================
849 // IEventProcessor implementation: stopRun(int)
850 //============================================================================
851 StatusCode ApplicationMgr::stopRun()
852 {
853 MsgStream log( m_messageSvc, name() );
854 if ( m_state == Gaudi::StateMachine::RUNNING ) {
855 if ( m_processingMgr ) {
856 return m_processingMgr->stopRun();
857 }
858 log << MSG::WARNING << "No EventLoop Manager specified " << endmsg;
859 return StatusCode::SUCCESS;
860 }
861 log << MSG::FATAL << "stopRun: Invalid state \"" << FSMState() << "\"" << endmsg;
862 return StatusCode::FAILURE;
863 }
864 // Implementation of IAppMgrUI::name
865 const std::string& ApplicationMgr::name() const { return m_name; }
866
867 // implementation of IService::state
868 Gaudi::StateMachine::State ApplicationMgr::FSMState() const { return m_state; }
869 // implementation of IService::state
870 Gaudi::StateMachine::State ApplicationMgr::targetFSMState() const { return m_targetState; }
871
872 //============================================================================
873 // implementation of IService::reinitilaize
874 //============================================================================
875 StatusCode ApplicationMgr::reinitialize()
876 {
877 StatusCode retval = StatusCode::SUCCESS;
878 StatusCode sc;
879 if ( m_state < Gaudi::StateMachine::INITIALIZED ) {
880 throw GaudiException( "Cannot reinitialize application if not INITIALIZED or RUNNING",
881 "ApplicationMgr::reinitialize", StatusCode::FAILURE );
882 }
883 if ( m_state == Gaudi::StateMachine::RUNNING ) {
884 retval = GoToState( Gaudi::StateMachine::INITIALIZED );
885 }
886 sc = svcManager()->reinitialize();
887 if ( sc.isFailure() ) retval = sc;
888 sc = algManager()->reinitialize();
889 if ( sc.isFailure() ) retval = sc;
890 return retval;
891 }
892
893 //============================================================================
894 // implementation of IService::reinitiaize
895 //============================================================================
896 StatusCode ApplicationMgr::restart()
897 {
898 StatusCode retval = StatusCode::SUCCESS;
899 StatusCode sc;
900 if ( m_state != Gaudi::StateMachine::RUNNING ) {
901 throw GaudiException( "Cannot restart application if not RUNNING", "ApplicationMgr::restart", StatusCode::FAILURE );
902 }
903 sc = svcManager()->restart();
904 if ( sc.isFailure() ) retval = sc;
905 sc = algManager()->restart();
906 if ( sc.isFailure() ) retval = sc;
907 return retval;
908 }
909
910 //============================================================================
911 // SI Go Handler
912 //============================================================================
913 void ApplicationMgr::SIGoHandler( Gaudi::Details::PropertyBase& )
914 {
915
916 MsgStream log( m_messageSvc, name() );
917 StatusCode sc;
918
919 // Re-initialize everything
920 sc = reinitialize();
921 // Execute a number of events
922 executeRun( m_evtMax );
923
924 return;
925 }
926
927 //============================================================================
928 // SI Exit Handler
929 //============================================================================
930 void ApplicationMgr::SIExitHandler( Gaudi::Details::PropertyBase& )
931 {
932 StatusCode status;
933 status = finalize();
934 status = terminate();
935 ::exit( 0 );
936 }
937
938 //============================================================================
939 // Handle properties of the event loop manager (Top alg/Output stream list)
940 //============================================================================
941 void ApplicationMgr::evtLoopPropertyHandler( Gaudi::Details::PropertyBase& p )
942 {
943 if ( m_processingMgr ) {
944 auto props = m_processingMgr.as<IProperty>();
945 if ( props ) props->setProperty( p ).ignore();
946 }
947 }
948
949 //============================================================================
950 // External Service List handler
951 //============================================================================
952 void ApplicationMgr::createSvcNameListHandler( Gaudi::Details::PropertyBase& /* theProp */ )
953 {
954 if ( !( decodeCreateSvcNameList() ).isSuccess() ) {
955 throw GaudiException( "Failed to create ext services", "MinimalEventLoopMgr::createSvcNameListHandler",
956 StatusCode::FAILURE );
957 }
958 }
959 //============================================================================
960 // decodeCreateSvcNameList
961 //============================================================================
962 StatusCode ApplicationMgr::decodeCreateSvcNameList()
963 {
964 StatusCode result = StatusCode::SUCCESS;
965 const auto& theNames = m_createSvcNameList.value();
966 auto it = theNames.begin();
967 auto et = theNames.end();
968 while ( result.isSuccess() && it != et ) {
969 Gaudi::Utils::TypeNameString item( *it++ );
970 if ( ( result = svcManager()->addService( item, ServiceManager::DEFAULT_SVC_PRIORITY ) ).isFailure() ) {
971 MsgStream log( m_messageSvc, m_name );
972 log << MSG::ERROR << "decodeCreateSvcNameList: Cannot create service " << item.type() << "/" << item.name()
973 << endmsg;
974 } else {
975 ON_DEBUG
976 {
977 MsgStream log( m_messageSvc, m_name );
978 log << MSG::DEBUG << "decodeCreateSvcNameList: Created service " << item.type() << "/" << item.name() << endmsg;
979 }
980 }
981 }
982 return result;
983 }
984
985 //============================================================================
986 // External Service List handler
987 //============================================================================
988 void ApplicationMgr::extSvcNameListHandler( Gaudi::Details::PropertyBase& /* theProp */ )
989 {
990 if ( !( decodeExtSvcNameList() ).isSuccess() ) {
991 throw GaudiException( "Failed to declare ext services", "MinimalEventLoopMgr::extSvcNameListHandler",
992 StatusCode::FAILURE );
993 }
994 }
995
996 //============================================================================
997 // decodeExtSvcNameList
998 //============================================================================
999 StatusCode ApplicationMgr::decodeExtSvcNameList()
1000 {
1001 StatusCode result = StatusCode::SUCCESS;
1002
1003 const auto& theNames = m_extSvcNameList.value();
1004
1005 auto it = theNames.begin();
1006 auto et = theNames.end();
1007 while ( result.isSuccess() && it != et ) {
1008 Gaudi::Utils::TypeNameString item( *it++ );
1009 if ( m_extSvcCreates ) {
1010 if ( ( result = svcManager()->addService( item, ServiceManager::DEFAULT_SVC_PRIORITY ) ).isFailure() ) {
1011 MsgStream log( m_messageSvc, m_name );
1012 log << MSG::ERROR << "decodeExtSvcNameList: Cannot create service " << item.type() << "/" << item.name()
1013 << endmsg;
1014 }
1015 } else {
1016 if ( ( result = svcManager()->declareSvcType( item.name(), item.type() ) ).isFailure() ) {
1017 MsgStream log( m_messageSvc, m_name );
1018 log << MSG::ERROR << "decodeExtSvcNameList: Cannot declare service " << item.type() << "/" << item.name()
1019 << endmsg;
1020 }
1021 }
1022 }
1023 return result;
1024 }
1025
1026 //============================================================================
1027 // External Service List handler
1028 //============================================================================
1029 void ApplicationMgr::multiThreadSvcNameListHandler( Gaudi::Details::PropertyBase& /* theProp */ )
1030 {
1031 if ( !( decodeMultiThreadSvcNameList() ).isSuccess() ) {
1032 throw GaudiException( "Failed to create copies of mt services",
1033 "MinimalEventLoopMgr::multiThreadSvcNameListHandler", StatusCode::FAILURE );
1034 }
1035 }
1036
1037 //============================================================================
1038 // decodeMultiExtSvcNameList
1039 //============================================================================
1040 StatusCode ApplicationMgr::decodeMultiThreadSvcNameList()
1041 {
1042 StatusCode result = StatusCode::SUCCESS;
1043 const auto& theNames = m_multiThreadSvcNameList.value();
1044 for ( int iCopy = 0; iCopy < m_noOfEvtThreads; ++iCopy ) {
1045 for ( const auto& it : theNames ) {
1046 Gaudi::Utils::TypeNameString item( it );
1047 result = addMultiSvc( item, ServiceManager::DEFAULT_SVC_PRIORITY );
1048 // FIXME SHOULD CLONE?
1049 if ( result.isFailure() ) {
1050 MsgStream log( m_messageSvc, m_name );
1051 log << MSG::ERROR << "decodeMultiThreadSvcNameList: Cannot create service " << item.type() << "/" << item.name()
1052 << endmsg;
1053 } else {
1054 ON_VERBOSE
1055 {
1056 MsgStream log( m_messageSvc, m_name );
1057 log << MSG::VERBOSE << "decodeMultiThreadSvcNameList: created service " << item.type() << "/" << item.name()
1058 << endmsg;
1059 }
1060 }
1061 }
1062 }
1063 return result;
1064 }
1065 //=============================================================================
1066 // declareMultiSvcType
1067 //=============================================================================
1068 StatusCode ApplicationMgr::declareMultiSvcType( const std::string& name, const std::string& type )
1069 {
1070 StatusCode result = StatusCode::SUCCESS;
1071 MsgStream log( m_messageSvc, m_name );
1072 if ( 0 == m_noOfEvtThreads ) {
1073 result = svcManager()->declareSvcType( name, type );
1074 if ( result.isFailure() ) {
1075 log << MSG::ERROR << "declareMultiSvcType: Cannot declare service " << type << "/" << name << endmsg;
1076 } else {
1077 ON_VERBOSE
1078 log << MSG::VERBOSE << "declareMultiSvcType: declared service " << type << "/" << name << endmsg;
1079 }
1080 } else {
1081 for ( int iCopy = 0; iCopy < m_noOfEvtThreads; ++iCopy ) {
1082 std::string thrName( name + getGaudiThreadIDfromID( iCopy ) );
1083 result = svcManager()->declareSvcType( thrName, type );
1084 if ( result.isFailure() ) {
1085 log << MSG::ERROR << "declareMultiSvcType: Cannot declare service " << type << "/" << thrName << endmsg;
1086 } else {
1087 ON_VERBOSE
1088 log << MSG::VERBOSE << "declareMultiSvcType: declared service " << type << "/" << thrName << endmsg;
1089 }
1090 }
1091 }
1092 return result;
1093 }
1094 //=============================================================================
1095 // addMultiSvc
1096 //=============================================================================
1097 StatusCode ApplicationMgr::addMultiSvc( const Gaudi::Utils::TypeNameString& typeName, int prio )
1098 {
1099 using Gaudi::Utils::TypeNameString;
1100 StatusCode result = StatusCode::SUCCESS;
1101 MsgStream log( m_messageSvc, m_name );
1102 if ( 0 == m_noOfEvtThreads ) {
1103 result = svcManager()->addService( typeName, prio );
1104 // result = svcManager()->addService(name, type, prio); // CHECKME???
1105 if ( result.isFailure() ) {
1106 log << MSG::ERROR << "addMultiSvc: Cannot add service " << typeName.type() << "/" << typeName.name() << endmsg;
1107 } else {
1108 ON_VERBOSE
1109 log << MSG::VERBOSE << "addMultiSvc: added service " << typeName.type() << "/" << typeName.name() << endmsg;
1110 }
1111 } else {
1112 for ( int iCopy = 0; iCopy < m_noOfEvtThreads; ++iCopy ) {
1113 const std::string& type = typeName.type();
1114 std::string thrName( typeName.name() + getGaudiThreadIDfromID( iCopy ) );
1115 result = svcManager()->addService( TypeNameString( thrName, type ), prio );
1116 if ( result.isFailure() ) {
1117 log << MSG::ERROR << "addMultiSvc: Cannot add service " << type << "/" << thrName << endmsg;
1118 } else {
1119 ON_VERBOSE
1120 log << MSG::VERBOSE << "addMultiSvc: added service " << type << "/" << thrName << endmsg;
1121 }
1122 }
1123 }
1124 return result;
1125 }
1126
1127 //============================================================================
1128 // Dll List handler
1129 //============================================================================
1130 void ApplicationMgr::dllNameListHandler( Gaudi::Details::PropertyBase& /* theProp */ )
1131 {
1132 if ( !( decodeDllNameList() ).isSuccess() ) {
1133 throw GaudiException( "Failed to load DLLs.", "MinimalEventLoopMgr::dllNameListHandler", StatusCode::FAILURE );
1134 }
1135 }
1136
1137 //============================================================================
1138 // decodeDllNameList
1139 //============================================================================
1140 StatusCode ApplicationMgr::decodeDllNameList()
1141 {
1142
1143 MsgStream log( m_messageSvc, m_name );
1144 StatusCode result = StatusCode::SUCCESS;
1145
1146 // Clean up multiple entries from DLL list
1147 // -------------------------------------------------------------------------
1148 std::vector<std::string> newList;
1149 std::map<std::string, unsigned int> dllInList, duplicateList;
1150 {
1151 for ( const auto it : m_dllNameList ) {
1152 if ( 0 == dllInList[it] ) {
1153 newList.push_back( it ); // first instance of this module
1154 } else {
1155 ++duplicateList[it];
1156 } // module listed multiple times
1157 ++dllInList[it]; // increment count for this module
1158 }
1159 }
1160 // m_dllNameList = newList; // update primary list to new, filtered list (do not use the
1161 // property itself otherwise we get called again infinitely)
1162 // List modules that were in there twice..
1163 ON_DEBUG if ( !duplicateList.empty() )
1164 {
1165 log << MSG::DEBUG << "Removed duplicate entries for modules : ";
1166 for ( auto it = duplicateList.begin(); it != duplicateList.end(); ++it ) {
1167 log << it->first << "(" << 1 + it->second << ")";
1168 if ( it != --duplicateList.end() ) log << ", ";
1169 }
1170 log << endmsg;
1171 }
1172 // -------------------------------------------------------------------------
1173
1174 const std::vector<std::string>& theNames = newList;
1175
1176 // only load the new dlls or previously failed dlls
1177 ON_DEBUG log << MSG::DEBUG << "Loading declared DLL's" << endmsg;
1178
1179 std::vector<std::string> successNames, failNames;
1180 for ( const auto& it : theNames ) {
1181 if ( std::find( m_okDlls.rbegin(), m_okDlls.rend(), it ) == m_okDlls.rend() ) {
1182 // found a new module name
1183 StatusCode status = m_classManager->loadModule( it );
1184 if ( status.isFailure() ) {
1185 failNames.push_back( it );
1186 result = StatusCode::FAILURE;
1187 } else {
1188 successNames.push_back( it );
1189 }
1190 }
1191 }
1192
1193 // report back to the user and store the names of the succesfully loaded dlls
1194 if ( !successNames.empty() ) {
1195 log << MSG::INFO << "Successfully loaded modules : ";
1196 for ( auto it = successNames.begin(); it != successNames.end(); it++ ) {
1197 log << ( *it );
1198 if ( ( it + 1 ) != successNames.end() ) log << ", ";
1199 // save name
1200 m_okDlls.push_back( *it );
1201 }
1202 log << endmsg;
1203 }
1204
1205 if ( result == StatusCode::FAILURE ) {
1206 log << MSG::WARNING << "Failed to load modules: ";
1207 for ( auto it = failNames.begin(); it != failNames.end(); it++ ) {
1208 log << ( *it );
1209 if ( ( it + 1 ) != failNames.end() ) log << ", ";
1210 }
1211 log << endmsg;
1212 }
1213 return result;
1214 }
1215
1216 //============================================================================
1217 // Plugin debug level handler
1218 //============================================================================
1219 void ApplicationMgr::pluginDebugPropertyHandler( Gaudi::Details::PropertyBase& )
1220 {
1221 // Setup debug level for the plugin system
1222 MsgStream log( m_messageSvc, name() );
1223 log << MSG::INFO << "Updating Gaudi::PluginService::SetDebug(level) to level=" << m_pluginDebugLevel << endmsg;
1224 Gaudi::PluginService::SetDebug( m_pluginDebugLevel );
1225 }
1226
1227 //============================================================================
1228 // Init loop check handler
1229 //============================================================================
1230 void ApplicationMgr::initLoopCheckHndlr( Gaudi::Details::PropertyBase& )
1231 {
1232 svcManager()->setLoopCheckEnabled( m_loopCheck );
1233 }
1234
1235 void ApplicationMgr::outputLevelUpdate()
1236 {
1237 resetMessaging();
1238 for ( auto& mgrItem : m_managers ) {
1239 mgrItem.second->outputLevelUpdate();
1240 }
1241 }
ServiceManager
The ServiceManager class is in charge of the creation of concrete instances of Services.
Definition: ServiceManager.h:36
ApplicationMgr::m_targetState
Gaudi::StateMachine::State m_targetState
Internal State.
Definition: ApplicationMgr.h:206
System::getEnv
GAUDI_API std::string getEnv(const char *var)
get a particular environment variable (returning "UNKNOWN" if not set)
Definition: System.cpp:581
AlgorithmManager
The AlgorithmManager class is in charge of the creation of concrete instances of Algorithms.
Definition: AlgorithmManager.h:31
ApplicationMgr::initialize
StatusCode initialize() override
Definition: ApplicationMgr.cpp:437
System.h
Gaudi::ReturnCode::FinalizationFailure
constexpr int FinalizationFailure
Error codes for operation failures.
Definition: AppReturnCode.h:34
UNLIKELY
#define UNLIKELY(x)
Definition: Kernel.h:128
ISvcManager::addService
virtual StatusCode addService(IService *svc, int prio=DEFAULT_SVC_PRIORITY)=0
Add a service to the "active" list of services of the factory.
MsgStream
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
StatusCode::SUCCESS
Definition: StatusCode.h:31
ApplicationMgr::m_propertiesPrint
Gaudi::Property< bool > m_propertiesPrint
Definition: ApplicationMgr.h:272
IEventProcessor::stopRun
virtual StatusCode stopRun()=0
Schedule a stop of the current event processing.
std::string::empty
T empty(T...args)
IRunable::run
virtual StatusCode run()=0
Run the class implementation.
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:22
ApplicationMgr::decodeDllNameList
StatusCode decodeDllNameList()
Definition: ApplicationMgr.cpp:1140
ApplicationMgr::m_returnCode
Gaudi::Property< int > m_returnCode
Property to record the error conditions occurring during the running.
Definition: ApplicationMgr.h:276
System::setEnv
GAUDI_API int setEnv(const std::string &name, const std::string &value, int overwrite=1)
Set an environment variables.
Definition: System.cpp:704
ApplicationMgr::SIExitHandler
void SIExitHandler(Gaudi::Details::PropertyBase &theProp)
Definition: ApplicationMgr.cpp:930
ApplicationMgr::m_stopOnSignal
Gaudi::Property< bool > m_stopOnSignal
Property to enable/disable the "stop on signal" service.
Definition: ApplicationMgr.h:264
DLLClassManager::loadModule
StatusCode loadModule(const std::string &module, bool fireIncident=true) override
Definition: DLLClassManager.cpp:30
Gaudi::StateMachine::CONFIGURED
Definition: StateMachine.h:16
ApplicationMgr::m_codeCheck
Gaudi::Property< bool > m_codeCheck
Definition: ApplicationMgr.h:245
ApplicationMgr::m_evtMax
Gaudi::Property< int > m_evtMax
Definition: ApplicationMgr.h:221
ApplicationMgr::m_runable
SmartIF< IRunable > m_runable
Reference to the runable object.
Definition: ApplicationMgr.h:213
StatusCode::FAILURE
Definition: StatusCode.h:31
compareRootHistos.state
state
Definition: compareRootHistos.py:424
PropertyHolder< CommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty > > >::property
Gaudi::Details::PropertyBase * property(const std::string &name) const
Definition: PropertyHolder.h:343
Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:319
PropertyHolder< CommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty > > >::setProperty
StatusCode setProperty(const Gaudi::Details::PropertyBase &p) override
set the property form another property
Definition: PropertyHolder.h:208
MsgStream.h
PropertyHolder< CommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty > > >::getProperties
const std::vector< Gaudi::Details::PropertyBase * > & getProperties() const override
get all properties
Definition: PropertyHolder.h:329
Gaudi::Details::PropertyBase::declareUpdateHandler
virtual PropertyBase & declareUpdateHandler(std::function< void(PropertyBase &)> fun)=0
set new callback for update
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:329
ApplicationMgr::SIGoHandler
void SIGoHandler(Gaudi::Details::PropertyBase &theProp)
Definition: ApplicationMgr.cpp:913
std::vector::rend
T rend(T...args)
ApplicationMgr::m_managers
ManagersMap m_managers
Map of known component managers.
Definition: ApplicationMgr.h:180
CommonMessaging< implements< IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty > >::resetMessaging
MSG::Level resetMessaging()
Reinitialize internal states.
Definition: CommonMessaging.h:181
IRunable.h
ApplicationMgr::m_jobOptionsType
Gaudi::Property< std::string > m_jobOptionsType
Definition: ApplicationMgr.h:231
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:75
ApplicationMgr::name
const std::string & name() const override
Definition: ApplicationMgr.cpp:865
MSG::DEBUG
Definition: IMessageSvc.h:16
std::endl
T endl(T...args)
ObjectFactory.h
ApplicationMgr::multiThreadSvcNameListHandler
void multiThreadSvcNameListHandler(Gaudi::Details::PropertyBase &theProp)
Definition: ApplicationMgr.cpp:1029
Gaudi::Time::current
static Time current()
Returns the current time.
Definition: Time.cpp:112
ApplicationMgr::m_environment
Gaudi::Property< std::map< std::string, std::string > > m_environment
Definition: ApplicationMgr.h:256
ApplicationMgr::m_multiThreadSvcNameList
Gaudi::Property< std::vector< std::string > > m_multiThreadSvcNameList
List of external services names for which we want a copy per evt thread.
Definition: ApplicationMgr.h:227
ApplicationMgr::outputLevelUpdate
void outputLevelUpdate() override
Function to call to update the outputLevel of the components (after a change in MessageSvc).
Definition: ApplicationMgr.cpp:1235
IEventProcessor::executeEvent
virtual StatusCode executeEvent(void *par=0)=0
Process single event.
ApplicationMgr::m_appVersion
Gaudi::Property< std::string > m_appVersion
Definition: ApplicationMgr.h:243
std::map::end
T end(T...args)
StatusCode::enableChecking
static GAUDI_API void enableChecking()
Definition: StatusCode.cpp:19
ApplicationMgr::m_okDlls
std::vector< std::string > m_okDlls
names of successfully loaded dlls
Definition: ApplicationMgr.h:283
Gaudi::StateMachine::State
State
Allowed states for classes implementing the state machine (ApplicationMgr, Algorithm, Service, AlgTool).
Definition: StateMachine.h:14
MSG::VERBOSE
Definition: IMessageSvc.h:16
ApplicationMgr::nextEvent
StatusCode nextEvent(int maxevt) override
Definition: ApplicationMgr.cpp:528
ApplicationMgr::m_jobOptionsSvc
SmartIF< IJobOptionsSvc > m_jobOptionsSvc
Reference to JobOption service.
Definition: ApplicationMgr.h:215
AlgorithmManager::typeAliases
AlgTypeAliasesMap & typeAliases()
Definition: AlgorithmManager.h:86
ISvcManager::declareSvcType
virtual StatusCode declareSvcType(const std::string &svcname, const std::string &svctype)=0
Declare the type of the service to be used when crating a given service name.
ApplicationMgr::createSvcNameListHandler
void createSvcNameListHandler(Gaudi::Details::PropertyBase &)
Definition: ApplicationMgr.cpp:952
std::map< std::string, unsigned int >
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
ThreadGaudi.h
ApplicationMgr::m_processingMgr
SmartIF< IEventProcessor > m_processingMgr
Reference to processing manager object.
Definition: ApplicationMgr.h:214
ApplicationMgr::terminate
StatusCode terminate() override
Definition: ApplicationMgr.cpp:636
ApplicationMgr::svcManager
SmartIF< ISvcManager > & svcManager()
Definition: ApplicationMgr.h:132
IStateful::start
virtual StatusCode start()=0
Start (from INITIALIZED to RUNNING).
Gaudi::ReturnCode::ScheduledStop
constexpr int ScheduledStop
Definition: AppReturnCode.h:27
compareRootHistos.retval
retval
Definition: compareRootHistos.py:427
ApplicationMgr::m_eventLoopMgr
Gaudi::Property< std::string > m_eventLoopMgr
Definition: ApplicationMgr.h:238
std::string
STL class.
ApplicationMgr.h
ApplicationMgr::addMultiSvc
StatusCode addMultiSvc(const Gaudi::Utils::TypeNameString &typeName, int prio)
add one or more copies of svc type/name as determined by NoOfThreads
Definition: ApplicationMgr.cpp:1097
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:82
IEventProcessor::nextEvent
virtual StatusCode nextEvent(int maxevt)=0
Process the next maxevt events.
ApplicationMgr::evtLoopPropertyHandler
void evtLoopPropertyHandler(Gaudi::Details::PropertyBase &theProp)
Definition: ApplicationMgr.cpp:941
MSG::FATAL
Definition: IMessageSvc.h:16
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:79
MSG::Level
Level
Definition: IMessageSvc.h:16
std::vector::push_back
T push_back(T...args)
InterfaceID
Interface ID class.
Definition: IInterface.h:29
Gaudi::PluginService::SetDebug
GAUDIPS_API void SetDebug(int debugLevel)
Backward compatibility with Reflex.
Definition: PluginService.cpp:350
IProperty::setProperty
virtual StatusCode setProperty(const Gaudi::Details::PropertyBase &p)=0
Set the property by property.
ApplicationMgr::m_outputLevel
Gaudi::Property< int > m_outputLevel
Definition: ApplicationMgr.h:241
SmartIF::as
SmartIF< IFace > as() const
return a new SmartIF instance to another interface
Definition: SmartIF.h:115
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:12
compareOutputFiles.par
string par
Definition: compareOutputFiles.py:437
AlgorithmManager.h
ApplicationMgr::executeRun
StatusCode executeRun(int evtmax) override
implementation of IEventProcessor::executeRun(int)
Definition: ApplicationMgr.cpp:834
IStateful::stop
virtual StatusCode stop()=0
Stop (from RUNNING to INITIALIZED).
IStateful::reinitialize
virtual StatusCode reinitialize()=0
Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).
ApplicationMgr::targetFSMState
Gaudi::StateMachine::State targetFSMState() const override
Definition: ApplicationMgr.cpp:870
ApplicationMgr::extSvcNameListHandler
void extSvcNameListHandler(Gaudi::Details::PropertyBase &theProp)
Definition: ApplicationMgr.cpp:988
ApplicationMgr::initLoopCheckHndlr
void initLoopCheckHndlr(Gaudi::Details::PropertyBase &)
Definition: ApplicationMgr.cpp:1230
IService
General service interface definition.
Definition: IService.h:18
ON_DEBUG
#define ON_DEBUG
Definition: ApplicationMgr.cpp:34
ApplicationMgr::m_svcLocator
SmartIF< ISvcLocator > m_svcLocator
Reference to its own service locator (must be instantiated prior to any service!) ...
Definition: ApplicationMgr.h:191
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
ISvcManager::createService
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...
declareProperty
Gaudi::Details::PropertyBase * declareProperty(const std::string &name, TYPE &value, const std::string &doc="none")
Declare a property (templated)
GaudiException.h
IInterface
Definition of the basic interface.
Definition: IInterface.h:277
gaudirun.type
type
Definition: gaudirun.py:133
IJobOptionsSvc::setMyProperties
virtual StatusCode setMyProperties(const std::string &client, IProperty *me)=0
Override default properties of the calling client.
SmartIF.h
ApplicationMgr::m_extSvcNameList
Gaudi::Property< std::vector< std::string > > m_extSvcNameList
Definition: ApplicationMgr.h:222
DECLARE_OBJECT_FACTORY
#define DECLARE_OBJECT_FACTORY(x)
Definition: ObjectFactory.h:16
ApplicationMgr::dllNameListHandler
void dllNameListHandler(Gaudi::Details::PropertyBase &theProp)
Definition: ApplicationMgr.cpp:1130
ApplicationMgr::m_runableType
Gaudi::Property< std::string > m_runableType
Definition: ApplicationMgr.h:237
MSG::NIL
Definition: IMessageSvc.h:16
DLLClassManager
Definition: DLLClassManager.h:27
getGaudiThreadIDfromID
GAUDI_API std::string getGaudiThreadIDfromID(int iCopy)
helper function to extract Gaudi Thread ID from thread copy number
Definition: ThreadGaudi.cpp:16
IMessageSvc.h
ApplicationMgr::m_stalledEventMonitoring
Gaudi::Property< bool > m_stalledEventMonitoring
Property to enable/disable the monitoring and reporting of stalled events.
Definition: ApplicationMgr.h:269
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: Property.h:32
Time.h
ApplicationMgr::GoToState
StatusCode GoToState(Gaudi::StateMachine::State state, bool ignoreFailures=false)
Reach a state from current state (whichever it is) going through the correct transitions.
Definition: ApplicationMgr.cpp:695
ApplicationMgr::finalize
StatusCode finalize() override
Definition: ApplicationMgr.cpp:584
ApplicationMgr::m_svcOptMapping
Gaudi::Property< std::vector< std::string > > m_svcOptMapping
Definition: ApplicationMgr.h:209
IStateful::initialize
virtual StatusCode initialize()=0
Initialization (from CONFIGURED to INITIALIZED).
IService.h
ApplicationMgr::m_jobOptionsPreAction
Gaudi::Property< std::string > m_jobOptionsPreAction
Definition: ApplicationMgr.h:233
ApplicationMgr::m_svcMapping
Gaudi::Property< std::vector< std::string > > m_svcMapping
Definition: ApplicationMgr.h:208
ApplicationMgr::m_dllNameList
Gaudi::Property< std::vector< std::string > > m_dllNameList
Definition: ApplicationMgr.h:230
System::isEnvSet
GAUDI_API bool isEnvSet(const char *var)
Check if an environment variable is set or not.
Definition: System.cpp:603
DLLClassManager::queryInterface
StatusCode queryInterface(const InterfaceID &iid, void **pinterface) override
implementation of IInterface::queryInterface
Definition: DLLClassManager.cpp:73
ApplicationMgr::executeEvent
StatusCode executeEvent(void *par) override
implementation of IEventProcessor::executeEvent(void*)
Definition: ApplicationMgr.cpp:819
ApplicationMgr
The Application Manager class.
Definition: ApplicationMgr.h:47
ApplicationMgr::m_actHistory
Gaudi::Property< bool > m_actHistory
Definition: ApplicationMgr.h:244
InterfaceID::versionMatch
constexpr bool versionMatch(const InterfaceID &iid) const
check compatibility.
Definition: IInterface.h:62
ApplicationMgr::queryInterface
StatusCode queryInterface(const InterfaceID &iid, void **pinterface) override
Definition: ApplicationMgr.cpp:93
ApplicationMgr::decodeExtSvcNameList
StatusCode decodeExtSvcNameList()
Definition: ApplicationMgr.cpp:999
std::find
T find(T...args)
System::hostName
GAUDI_API const std::string & hostName()
Host name.
Definition: System.cpp:403
Gaudi::StateMachine::RUNNING
Definition: StateMachine.h:18
ApplicationMgr::m_extSvcCreates
Gaudi::Property< bool > m_extSvcCreates
Definition: ApplicationMgr.h:223
std::vector< std::string >
ApplicationMgr::m_classManager
SmartIF< DLLClassManager > m_classManager
Reference to the class manager.
Definition: ApplicationMgr.h:193
ApplicationMgr::m_jobOptionsSvcType
Gaudi::Property< std::string > m_jobOptionsSvcType
Definition: ApplicationMgr.h:202
ApplicationMgr::start
StatusCode start() override
Definition: ApplicationMgr.cpp:494
ApplicationMgr::m_createSvcNameList
Gaudi::Property< std::vector< std::string > > m_createSvcNameList
Definition: ApplicationMgr.h:248
ApplicationMgr::restart
StatusCode restart() override
Definition: ApplicationMgr.cpp:896
ApplicationMgr::configure
StatusCode configure() override
Definition: ApplicationMgr.cpp:241
gaudiComponentHelp.properties
properties
Definition: gaudiComponentHelp.py:41
std::map::begin
T begin(T...args)
ApplicationMgr::pluginDebugPropertyHandler
void pluginDebugPropertyHandler(Gaudi::Details::PropertyBase &theProp)
Definition: ApplicationMgr.cpp:1219
IStateful::restart
virtual StatusCode restart()=0
Initialization (from RUNNING to RUNNING, via INITIALIZED).
ApplicationMgr::stopRun
StatusCode stopRun() override
implementation of IEventProcessor::stopRun()
Definition: ApplicationMgr.cpp:851
Gaudi::Utils::TypeNameString::type
const std::string & type() const
Definition: TypeNameString.h:39
ApplicationMgr::decodeCreateSvcNameList
StatusCode decodeCreateSvcNameList()
Definition: ApplicationMgr.cpp:962
IStateful::finalize
virtual StatusCode finalize()=0
Finalize (from INITIALIZED to CONFIGURED).
ApplicationMgr::m_jobOptionsPostAction
Gaudi::Property< std::string > m_jobOptionsPostAction
Definition: ApplicationMgr.h:235
std::string::c_str
T c_str(T...args)
ServiceManager.h
TypeNameString.h
DLLClassManager.h
ApplicationMgr::i_startup
StatusCode i_startup()
Internal startup routine.
Definition: ApplicationMgr.cpp:130
ApplicationMgr::stop
StatusCode stop() override
Definition: ApplicationMgr.cpp:546
ApplicationMgr::m_name
std::string m_name
Name.
Definition: ApplicationMgr.h:204
MSG::ERROR
Definition: IMessageSvc.h:16
IInterface::addRef
virtual unsigned long addRef()=0
Increment the reference count of Interface instance.
StatusCode::disableChecking
static GAUDI_API void disableChecking()
Definition: StatusCode.cpp:21
ApplicationMgr::m_messageSvcType
Gaudi::Property< std::string > m_messageSvcType
Definition: ApplicationMgr.h:201
ON_VERBOSE
#define ON_VERBOSE
Definition: ApplicationMgr.cpp:35
ApplicationMgr::reinitialize
StatusCode reinitialize() override
Definition: ApplicationMgr.cpp:875
MsgStream::level
MSG::Level level() const
Retrieve output level.
Definition: MsgStream.h:108
MSG::WARNING
Definition: IMessageSvc.h:16
ApplicationMgr::m_state
Gaudi::StateMachine::State m_state
Internal State.
Definition: ApplicationMgr.h:205
StatusCode.h
ApplicationMgr::m_appName
Gaudi::Property< std::string > m_appName
Definition: ApplicationMgr.h:242
ApplicationMgr::FSMState
Gaudi::StateMachine::State FSMState() const override
Definition: ApplicationMgr.cpp:868
Gaudi::Utils::TypeNameString::name
const std::string & name() const
Definition: TypeNameString.h:40
ApplicationMgr::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Needed to locate the message service.
Definition: ApplicationMgr.h:151
ISvcManager::setLoopCheckEnabled
virtual void setLoopCheckEnabled(bool en=true)=0
Set the value of the initialization loop check flag.
IEventProcessor::executeRun
virtual StatusCode executeRun(int maxevt)=0
Process the maxevt events as a Run (beginRun() and endRun() called)
maxevt
int maxevt
Definition: Bootstrap.cpp:279
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:109
Gaudi::ReturnCode::Success
constexpr int Success
Definition: AppReturnCode.h:18
ApplicationMgr::run
StatusCode run() override
Definition: ApplicationMgr.cpp:790
GaudiDict::typeName
std::string typeName(const std::type_info &typ)
Definition: Dictionary.cpp:23
queryInterface
StatusCode queryInterface(const InterfaceID &iid, void **pinterface) override
MSG::INFO
Definition: IMessageSvc.h:16
ApplicationMgr::decodeMultiThreadSvcNameList
StatusCode decodeMultiThreadSvcNameList()
Definition: ApplicationMgr.cpp:1040
IProperty
The IProperty is the basic interface for all components which have properties that can be set or get...
Definition: IProperty.h:20
Gaudi::StateMachine::OFFLINE
Definition: StateMachine.h:15
ApplicationMgr::algManager
SmartIF< IAlgManager > & algManager()
Definition: ApplicationMgr.h:141
IInterface::interfaceID
static const InterfaceID & interfaceID()
Return an instance of InterfaceID identifying the interface.
Definition: IInterface.h:287
ApplicationMgr::m_noOfEvtThreads
Gaudi::Property< int > m_noOfEvtThreads
Definition: ApplicationMgr.h:228
ApplicationMgr::m_messageSvc
SmartIF< IMessageSvc > m_messageSvc
Reference to the message service.
Definition: ApplicationMgr.h:212
MSG::ALWAYS
Definition: IMessageSvc.h:16
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
ApplicationMgr::m_pluginDebugLevel
Gaudi::Property< int > m_pluginDebugLevel
Definition: ApplicationMgr.h:246
ApplicationMgr::m_jobOptionsPath
Gaudi::Property< std::string > m_jobOptionsPath
Definition: ApplicationMgr.h:232
IMessageSvc::setOutputLevel
virtual void setOutputLevel(int new_level)=0
Set new global output level threshold.
Gaudi::Time::format
std::string format(bool local, std::string spec="%c") const
Format the time using strftime.
Definition: Time.cpp:260
Gaudi.Configuration.log
log
Definition: Configuration.py:13
ApplicationMgr::m_loopCheck
Gaudi::Property< bool > m_loopCheck
Definition: ApplicationMgr.h:259
IInterface::queryInterface
virtual StatusCode queryInterface(const InterfaceID &ti, void **pp)=0
Set the void** to the pointer to the requested interface of the instance.
std::numeric_limits
IJobOptionsSvc.h
ApplicationMgr::declareMultiSvcType
StatusCode declareMultiSvcType(const std::string &name, const std::string &type)
declare one or more copies of svc type/name as determined by NoOfThreads
Definition: ApplicationMgr.cpp:1068
std::vector::rbegin
T rbegin(T...args)