ApplicationMgr.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef GAUDI_APPLICATIONMGR_H
#define GAUDI_APPLICATIONMGR_H
 
#include <Gaudi/Interfaces/IQueueingEventProcessor.h>
#include <Gaudi/MonitoringHub.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>
#include <vector>
 
// Forward declarations
class ISvcLocator;
class ServiceManager;
class AlgorithmManager;
class DLLClassManager;
 
class IMessageSvc;
class IIncidentSvc;
class IRunable;
class IDataManagerSvc;
class IConversionSvc;
 
class ApplicationMgr
    : public PropertyHolder<CommonMessaging<implements<IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, 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;
  EventContext createEventContext() override;
  StatusCode executeEvent( EventContext&& ctx ) 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; }
 
  void                                                                  push( EventContext&& ctx ) override;
  bool                                                                  empty() const override;
  std::optional<Gaudi::Interfaces::IQueueingEventProcessor::ResultType> pop() override;
 
 
  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 );
 
  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;
 
  Gaudi::Monitoring::Hub& monitoringHub() override { return m_monitoringHub; }
 
  void printAlgsSequences();
 
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,
                               [this]( auto& ) {
                                 // Re-initialize everything
                                 this->reinitialize().ignore();
                                 // Execute a number of events
                                 this->executeRun( m_evtMax ).ignore();
                               },
                               "For SI's \"Go\" command via callback" };
  Gaudi::Property<int>                      m_SIExit{ this, "Exit", 0,
                                 [this]( auto& ) {
                                   finalize().ignore();
                                   terminate().ignore();
                                   ::exit( 0 );
                                 },
                                 "For SI's \"Exit\" command via callback" };
  Gaudi::Property<std::vector<std::string>> m_topAlgNameList{ this,
                                                              "TopAlg",
                                                              {},
                                                              &ApplicationMgr::evtLoopPropertyHandler,
                                                              "List of top level algorithms names",
                                                              "vector<Algorithm>" };
  Gaudi::Property<std::vector<std::string>> m_outStreamNameList{
      this, "OutStream", {}, &ApplicationMgr::evtLoopPropertyHandler, "List of output stream names" };
  Gaudi::Property<std::string> m_messageSvcType{ this, "MessageSvcType", "MessageSvc", "MessageSvc type",
                                                 "Service:IMessageSvc" };
  Gaudi::Property<std::string> m_jobOptionsSvcType{ this, "JobOptionsSvcType", "JobOptionsSvc", "JobOptionsSvc type",
                                                    "Service:Gaudi::Interfaces::IOptionsSvc" };
 
  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<IQueueingEventProcessor> m_queueingProcessor; 
 
  Gaudi::Monitoring::Hub m_monitoringHub;
 
  //
  // 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", "vector<Service>" };
  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", "Service:IRunable" };
  Gaudi::Property<std::string> m_eventLoopMgr{ this, "EventLoop", "EventLoopMgr", "Processing manager type",
                                               "Service:IEventProcessor" };
  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<int>         m_pluginDebugLevel{ this, "PluginDebugLevel", 0,
                                           [this]( auto& ) {
                                             // Setup debug level for the plugin system
                                             if ( m_pluginDebugLevel.value() ) {
                                               MsgStream log( m_messageSvc, this->name() );
                                               log << MSG::INFO
                                                   << "Updating Gaudi::PluginService::SetDebug(level) to level="
                                                   << m_pluginDebugLevel.value() << endmsg;
                                             }
                                             Gaudi::PluginService::SetDebug( m_pluginDebugLevel );
                                           },
                                           "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,
                                     [this]( auto& ) { this->svcManager()->setLoopCheckEnabled( m_loopCheck ); },
                                     "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_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." };
 
  Gaudi::Property<bool> m_printAlgsSequence{ this, "PrintAlgsSequence", false,
                                             "Print the sequence of algorithms that have been loaded." };
 
  Gaudi::Property<bool> m_useMessageSvcForROOTMessages{ this, "UseMessageSvcForROOTMessages", true,
                                                        "Replace ROOT error handler with MessageSvc." };
 
  // For concurrency
  bool m_useHiveAlgorithmManager;
 
private:
  std::vector<std::string> m_okDlls; 
 
  template <typename SELF, typename PIMPL, typename METHOD, typename... ARGS>
  static auto i_delegateToEvtProc( SELF* self, PIMPL& member, std::string_view method_name, METHOD&& method,
                                   ARGS&&... args ) {
    if ( self->m_state == Gaudi::StateMachine::RUNNING ) {
      if ( bool( member ) ) {
        return std::invoke( method, *member.get(), std::forward<ARGS>( args )... );
      } else {
        std::stringstream s;
        s << method_name << ": event processor is not a \""
          << System::typeinfoName( typeid( decltype( *member.get() ) ) ) << '"';
        throw GaudiException{ s.str(), self->name(), StatusCode::FAILURE };
      }
    }
    std::stringstream s;
    s << method_name << ": Invalid state \"" << self->FSMState() << '"';
    throw GaudiException{ s.str(), self->name(), StatusCode::FAILURE };
  }
};
#endif // GAUDI_APPLICATIONMGR_H