ApplicationMgr.h

Go to the documentation of this file.

#ifndef GAUDI_APPLICATIONMGR_H
#define GAUDI_APPLICATIONMGR_H

#include "GaudiKernel/AppReturnCode.h"
#include "GaudiKernel/CommonMessaging.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IAppMgrUI.h"
#include "GaudiKernel/IComponentManager.h"
#include "GaudiKernel/IEventProcessor.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/IStateful.h"
#include "GaudiKernel/ISvcManager.h"
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/PropertyHolder.h"
#include "GaudiKernel/Service.h"

// STL include files
#include <list>
#include <vector>

// Forward declarations
class ISvcLocator;
class ServiceManager;
class AlgorithmManager;
class DLLClassManager;

class IMessageSvc;
class IIncidentSvc;
class IRunable;
class IDataManagerSvc;
class IConversionSvc;
class IJobOptionsSvc;

class ApplicationMgr
    : public PropertyHolder<
          CommonMessaging<implements<IAppMgrUI, IEventProcessor, IService, IStateful, INamedInterface, IProperty>>>
{
public:
  // default creator
  ApplicationMgr( IInterface* = nullptr );

  // implementation of IInterface::queryInterface
  StatusCode queryInterface( const InterfaceID& iid, void** pinterface ) override;

  // implementation of IAppMgrUI::run
  StatusCode run() override;
  // implementation of IAppMgrUI::configure
  StatusCode configure() override;
  // implementation of IAppMgrUI::terminate
  StatusCode terminate() override;
  // implementation of IAppMgrUI::initialize
  StatusCode initialize() override;
  // implementation of IAppMgrUI::start
  StatusCode start() override;
  // implementation of IAppMgrUI::stop
  StatusCode stop() override;
  // implementation of IAppMgrUI::finalize
  StatusCode finalize() override;
  // implementation of IAppMgrUI::nextEvent
  StatusCode nextEvent( int maxevt ) override;
  // implementation of IAppMgrUI::name
  const std::string& name() const override;
  StatusCode executeEvent( void* par ) override;
  StatusCode executeRun( int evtmax ) override;
  StatusCode stopRun() override;

  // implementation of IStateful::state
  Gaudi::StateMachine::State FSMState() const override;
  // implementation of IStateful::targetState
  Gaudi::StateMachine::State targetFSMState() const override;
  // implementation of IStateful::reinitialize
  StatusCode reinitialize() override;
  // implementation of IStateful::reinitialize
  StatusCode restart() override;
  // implementation of IService::sysItinitilaize
  StatusCode sysInitialize() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysStart
  StatusCode sysStart() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysStop
  StatusCode sysStop() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysFinalize
  StatusCode sysFinalize() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysReinitialize
  StatusCode sysReinitialize() override { return StatusCode::SUCCESS; }
  // implementation of IService::sysRestart
  StatusCode sysRestart() override { return StatusCode::SUCCESS; }

  // SI Go Handler
  void SIGoHandler( Gaudi::Details::PropertyBase& theProp );
  // SI Exit handler
  void SIExitHandler( Gaudi::Details::PropertyBase& theProp );


  void evtLoopPropertyHandler( Gaudi::Details::PropertyBase& theProp );
  StatusCode decodeExtSvcNameList();
  StatusCode decodeCreateSvcNameList();
  void       createSvcNameListHandler( Gaudi::Details::PropertyBase& );
  void extSvcNameListHandler( Gaudi::Details::PropertyBase& theProp );
  StatusCode decodeDllNameList();
  void dllNameListHandler( Gaudi::Details::PropertyBase& theProp );
  void pluginDebugPropertyHandler( Gaudi::Details::PropertyBase& theProp );
  void initLoopCheckHndlr( Gaudi::Details::PropertyBase& );

  template <class I>
  SmartIF<IComponentManager>& getManager()
  {
    return m_managers[I::interfaceID().id()];
  }

  inline SmartIF<ISvcManager>& svcManager()
  {
    // Cache the casted pointer to ISvcManager
    if ( !m_svcManager ) {
      m_svcManager = getManager<IService>();
    }
    return m_svcManager;
  }

  inline SmartIF<IAlgManager>& algManager()
  {
    // Cache the casted pointer to IAlgManager
    if ( !m_algManager ) {
      m_algManager = getManager<IAlgorithm>();
    }
    return m_algManager;
  }

  SmartIF<ISvcLocator>& serviceLocator() const override { return m_svcLocator; }

  void outputLevelUpdate() override;

protected:
  // implementation of IService::setServiceManager
  void setServiceManager( ISvcManager* ) override {}

  StatusCode i_startup();

  StatusCode GoToState( Gaudi::StateMachine::State state, bool ignoreFailures = false );

  typedef std::map<unsigned long, SmartIF<IComponentManager>> ManagersMap;
  ManagersMap m_managers;
  Gaudi::Property<std::vector<std::string>> m_declaredManagers;

  SmartIF<ISvcManager> m_svcManager;

  SmartIF<IAlgManager> m_algManager;

  // data members
  mutable SmartIF<ISvcLocator> m_svcLocator; 
  SmartIF<DLLClassManager> m_classManager;   

  Gaudi::Property<int>                      m_SIGo{this, "Go", 0, "For SI's \"Go\" command via callback"};
  Gaudi::Property<int>                      m_SIExit{this, "Exit", 0, "For SI's \"Exit\" command via callback"};
  Gaudi::Property<std::vector<std::string>> m_topAlgNameList{this, "TopAlg", {}, "List of top level algorithms names"};
  Gaudi::Property<std::vector<std::string>> m_outStreamNameList{this, "OutStream", {}, "List of output stream names"};
  Gaudi::Property<std::string>              m_outStreamType{this, "OutStreamType", "OutputStream",
                                               "[[deprecated]] Output stream type"};
  Gaudi::Property<std::string> m_messageSvcType{this, "MessageSvcType", "MessageSvc", "MessageSvc type"};
  Gaudi::Property<std::string> m_jobOptionsSvcType{this, "JobOptionsSvcType", "JobOptionsSvc", "JobOptionsSvc type"};

  std::string                m_name        = "ApplicationMgr";             
  Gaudi::StateMachine::State m_state       = Gaudi::StateMachine::OFFLINE; 
  Gaudi::StateMachine::State m_targetState = Gaudi::StateMachine::OFFLINE; 

  Gaudi::Property<std::vector<std::string>> m_svcMapping{this, "SvcMapping", {}, "Default mapping of services"};
  Gaudi::Property<std::vector<std::string>> m_svcOptMapping{
      this, "SvcOptMapping", {}, "Default mapping of optional services"};

  SmartIF<IMessageSvc>     m_messageSvc;    
  SmartIF<IRunable>        m_runable;       
  SmartIF<IEventProcessor> m_processingMgr; 
  SmartIF<IJobOptionsSvc>  m_jobOptionsSvc; 

  //
  // The public ApplicationMgr properties
  //

  Gaudi::Property<int> m_evtMax{this, "EvtMax", -1, "Number of events to be processed (-1 means all events)"};
  Gaudi::Property<std::vector<std::string>> m_extSvcNameList{this, "ExtSvc", {}, "List of external services names"};
  Gaudi::Property<bool>                     m_extSvcCreates{this, "ExtSvcCreates", true,
                                        "LHCb (default) or ATLAS definition of \"ExtSvc\""};

  Gaudi::Property<std::vector<std::string>> m_dllNameList{this, "Dlls", {}, "List of DDL's names"};
  Gaudi::Property<std::string> m_jobOptionsType{this, "JobOptionsType", "FILE", "Source type (e.g. dbase, file...)"};
  Gaudi::Property<std::string> m_jobOptionsPath{this, "JobOptionsPath", {}, "The \"file\" to look for properties"};
  Gaudi::Property<std::string> m_jobOptionsPreAction{
      this, "JobOptionsPostAction", {}, "additional command to run on config"};
  Gaudi::Property<std::string> m_jobOptionsPostAction{
      this, "JobOptionsPreAction", {}, "additional command to run on config"};
  Gaudi::Property<std::string> m_runableType{this, "Runable", "AppMgrRunable", "Runable type"};
  Gaudi::Property<std::string> m_eventLoopMgr{this, "EventLoop", "EventLoopMgr", "Processing manager type"};
  Gaudi::Property<std::string> m_evtsel{this, "EvtSel", {}, "Event selection"};
  Gaudi::Property<std::string> m_histPersName{this, "HistogramPersistency", "NONE", "Name of the Hist Pers Svc"};
  Gaudi::Property<int>         m_outputLevel{this, "OutputLevel", MSG::INFO, "Message output level"};
  Gaudi::Property<std::string> m_appName{this, "AppName", "ApplicationMgr", "The name of the application"};
  Gaudi::Property<std::string> m_appVersion{this, "AppVersion", {}, "The version of the application"};
  Gaudi::Property<bool>        m_actHistory{this, "ActivateHistory", false, "Activate HistorySvc"};
  Gaudi::Property<bool>        m_codeCheck{this, "StatusCodeCheck", false, "Activate StatusCode checking"};
  Gaudi::Property<int>         m_pluginDebugLevel{this, "PluginDebugLevel", 0, "Debug level for the plugin system"};

  Gaudi::Property<std::vector<std::string>> m_createSvcNameList{
      this, "CreateSvc", {}, "List of extra services to be created"};

  Gaudi::Property<bool> m_auditTools{this, "AuditTools", false};
  Gaudi::Property<bool> m_auditSvcs{this, "AuditServices", false};
  Gaudi::Property<bool> m_auditAlgs{this, "AuditAlgorithms", false};

  Gaudi::Property<std::map<std::string, std::string>> m_environment{
      this, "Environment", {}, "Environment variables to set"};

  Gaudi::Property<bool> m_loopCheck{this, "InitializationLoopCheck", true,
                                    "For ServiceMgr initialization loop checking"};

  Gaudi::Property<bool> m_stopOnSignal{
      this, "StopOnSignal", false, "Flag to enable/disable the signal handler that schedule a stop of the event loop"};

  Gaudi::Property<bool> m_stalledEventMonitoring{
      this, "StalledEventMonitoring", false, "Flag to enable/disable the monitoring and reporting of stalled events"};

  Gaudi::Property<bool> m_propertiesPrint{this, "PropertiesPrint", false,
                                          "Flag to activate the printout of properties"};

  Gaudi::Property<int> m_returnCode{this, "ReturnCode", Gaudi::ReturnCode::Success,
                                    "Return code of the application. Set internally in case of error conditions."};

  // For concurrency
  bool m_useHiveAlgorithmManager;

private:
  std::vector<std::string> m_okDlls; 
};
#endif // GAUDI_APPLICATIONMGR_H