| The Gaudi Framework v28r2p1 (f1a77ff4)

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