HistorySvc Class Reference

HistorySvc class definition. More...

#include <src/HistorySvc.h>

Inheritance diagram for HistorySvc:

Collaboration diagram for HistorySvc:

Public Member Functions
virtual StatusCode	initialize ()
virtual StatusCode	reinitialize ()
virtual StatusCode	finalize ()
virtual StatusCode	stop ()
virtual StatusCode	captureState ()
virtual StatusCode	registerJob ()
virtual StatusCode	listProperties () const
virtual JobHistory *	getJobHistory () const
virtual StatusCode	registerSvc (const IService &)
virtual StatusCode	listProperties (const IService &) const
virtual ServiceHistory *	getServiceHistory (const IService &) const
virtual void	getServiceHistory (std::set< ServiceHistory * > &) const
virtual StatusCode	registerAlg (const Algorithm &)
virtual StatusCode	listProperties (const Algorithm &) const
virtual AlgorithmHistory *	getAlgHistory (const Algorithm &) const
virtual void	getAlgHistory (std::set< AlgorithmHistory * > &) const
virtual StatusCode	registerAlgTool (const IAlgTool &)
virtual StatusCode	listProperties (const IAlgTool &) const
virtual AlgToolHistory *	getAlgToolHistory (const IAlgTool &) const
virtual void	getAlgToolHistory (std::set< AlgToolHistory * > &) const
virtual DataHistory *	createDataHistoryObj (const CLID &id, const std::string &key, const std::string &store)
virtual StatusCode	registerDataHistory (const CLID &id, const std::string &key, const std::string &store)
virtual DataHistory *	getDataHistory (const CLID &id, const std::string &key, const std::string &store) const
virtual int	getDataHistory (const CLID &id, const std::string &key, const std::string &storeName, std::list< DataHistory * > &dhlist) const
	HistorySvc (const std::string &name, ISvcLocator *svc)
virtual void	handle (const Incident &inc)
virtual	~HistorySvc ()=default
Public Member Functions inherited from extends< BASE, Interfaces >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...
	~extend_interfaces () override=default
	Virtual destructor. More...

Private Types
typedef IVersHistoryObj::PropertyList	PropertyList
typedef std::multimap< DHH, DataHistory * >	DataHistMap
typedef DataHistMap::iterator	DHMitr
typedef DataHistMap::const_iterator	DHMCitr

Private Member Functions
void	clearState ()
void	dumpProperties (std::ofstream &) const
void	dumpProperties (const IService &, std::ofstream &) const
void	dumpProperties (const Algorithm &, std::ofstream &) const
void	dumpProperties (const IAlgTool &, std::ofstream &) const
void	dumpState (std::ofstream &) const
void	dumpState (const INamedInterface *, std::ofstream &) const
std::string	dumpProp (const Property *, const bool isXML=false, int indent=0) const
IAlgorithm *	getCurrentIAlg () const

Private Attributes
bool	m_isInitialized = false
bool	m_dump = false
bool	m_activate = true
IAlgContextSvc *	p_algCtxSvc = nullptr
std::map< const Algorithm *, AlgorithmHistory * >	m_algmap
std::set< const IAlgTool * >	m_ialgtools
std::map< const AlgTool *, AlgToolHistory * >	m_algtoolmap
std::map< const IService *, ServiceHistory * >	m_svcmap
std::multimap< DHH, DataHistory * >	m_datMap
std::unique_ptr< JobHistory >	m_jobHistory
std::string	m_outputFile
IIncidentSvc *	m_incidentSvc = nullptr
SmartIF< IToolSvc >	m_toolSvc
MsgStream	m_log
bool	m_outputFileTypeXML = false

Additional Inherited Members
Public Types inherited from extends< BASE, Interfaces >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
Public Types inherited from extend_interfaces< Interfaces...>
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Detailed Description

HistorySvc class definition.

Definition at line 41 of file HistorySvc.h.

Member Typedef Documentation

typedef std::multimap<DHH,DataHistory*> HistorySvc::DataHistMap

private

Definition at line 96 of file HistorySvc.h.

typedef DataHistMap::const_iterator HistorySvc::DHMCitr

private

Definition at line 98 of file HistorySvc.h.

typedef DataHistMap::iterator HistorySvc::DHMitr

private

Definition at line 97 of file HistorySvc.h.

typedef IVersHistoryObj::PropertyList HistorySvc::PropertyList

private

Definition at line 94 of file HistorySvc.h.

Constructor & Destructor Documentation

HistorySvc::HistorySvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 76 of file HistorySvc.cpp.

  : base_class( name, svc ),
    m_log(msgSvc(), name )
{
    declareProperty("Dump",m_dump);
    declareProperty("Activate", m_activate=true);
    declareProperty("OutputFile",m_outputFile);

    // hack to bring in environ
    vector<string> envtmp = System::getEnv();
    envtmp.size(); // prevent icc remark #177: X declared but never referenced
}

virtual HistorySvc::~HistorySvc ( )

virtualdefault

Member Function Documentation

StatusCode HistorySvc::captureState ( )

virtual

Get all the Algorithms

Get all the AlgTools

Get all the Services

Definition at line 184 of file HistorySvc.cpp.

                                    {

  if (!m_jobHistory ) {
    m_jobHistory.reset( new JobHistory );
    IJobOptionsSvc *jo;
    if (service("JobOptionsSvc",jo).isFailure()) {
       m_log << MSG::ERROR
         << "Could not get jobOptionsSvc - "
         << "not adding properties to JobHistory" << endmsg;
    } else {

      bool foundAppMgr(false);

      for (auto& client: jo->getClients()) {
        if (client == "ApplicationMgr") foundAppMgr = true;
        for (auto prop: *jo->getProperties(client)) {
          m_jobHistory->addProperty(client, prop);
        }
      }

      if (!foundAppMgr) {
    auto ap = service<IProperty>("ApplicationMgr");
    if (!ap) {
      m_log << MSG::ERROR << "could not get the ApplicationMgr" << endmsg;
    } else {
      for (auto prop: ap->getProperties()) {
        m_jobHistory->addProperty("ApplicationMgr", prop);
      }
    }
      }

    }
  }


  auto algMgr = Gaudi::svcLocator()->as<IAlgManager>();
  if ( !algMgr ) {
    m_log << MSG::ERROR << "Could not get AlgManager" << endmsg;
    return StatusCode::FAILURE;
  }

  size_t count = 0;
  for (auto ialg: algMgr->getAlgorithms()) {
    Algorithm* alg = dynamic_cast<Algorithm*>(ialg);
    if ( !alg ) {
      m_log << MSG::WARNING << "Algorithm " << ialg->name()
            << " does not inherit from Algorithm. Not registering it."
            << endmsg;
    } else {
      ++count;
      registerAlg( *alg ).ignore();
    }
  }

  m_log << MSG::INFO << "Registered " << count << " Algorithms" << endmsg;




  m_isInitialized = true;
  for (auto algtool: m_ialgtools) {
    (const_cast<IAlgTool*>(algtool))->addRef();
    registerAlgTool(*algtool).ignore();
  }

  m_log << MSG::INFO << "Registered " << m_algtoolmap.size() << " AlgTools"
    << endmsg;


  for (auto svc: Gaudi::svcLocator()->getServices()) {
    svc->addRef();
    registerSvc(*svc).ignore();
  }

  m_log << MSG::INFO;
  m_log << "Registered " << Gaudi::svcLocator()->getServices().size() << " Services" << endmsg;

  return StatusCode::SUCCESS;


}

void HistorySvc::clearState ( )

private

Definition at line 115 of file HistorySvc.cpp.

                            {
  clear(m_algmap);

  m_ialgtools.clear();
  clear(m_algtoolmap);

  clear(m_svcmap);
}

DataHistory * HistorySvc::createDataHistoryObj ( const CLID &  id, const std::string &  key, const std::string &  store  )

virtual

Definition at line 495 of file HistorySvc.cpp.

                                     {

  if (!m_activate) return nullptr;


  AlgorithmHistory *algHist = nullptr;

  IAlgorithm* ialg = getCurrentIAlg();
  if ( !ialg ) {
    ON_DEBUG
      m_log << MSG::DEBUG
        << "Could not discover current Algorithm:" << endl
        << "          object CLID: " << id << "  key: \"" << key
        << "\"" << endmsg;
    algHist = nullptr;
  } else {
    Algorithm* alg = dynamic_cast<Algorithm*>(ialg);
    if ( alg ) {
      algHist = getAlgHistory( *alg );
    } else {
      m_log << MSG::WARNING
            << "Could not extract concrete Algorithm:"
            << endl
            << "          object CLID: " << id << "  key: \"" << key
            << "\"" << endmsg;
      algHist = nullptr;
    }
  }
  return new DataHistory(id, key, algHist);
}

std::string HistorySvc::dumpProp ( const Property *  prop, const bool  isXML = false, int  indent = 0  ) const

private

Definition at line 797 of file HistorySvc.cpp.

                                                                    {
  std::ostringstream ost;
  if (isXML) {
    while (ind > 0) {
      ost << " ";
      ind --;
    }
    ost << "<PROPERTY name=\"" << prop->name()
    << "\" value=\"" << HistoryObj::convert_string(prop->toString())
    << "\" documentation=\"" << HistoryObj::convert_string(prop->documentation())
    << "\">";
  } else {
    prop->fillStream(ost);
  }
  return ost.str();
}

void HistorySvc::dumpProperties ( std::ofstream &  ofs ) const

private

Definition at line 456 of file HistorySvc.cpp.

                                                 {

  ofs << "GLOBAL" << std::endl;
  for (const auto & prop : m_jobHistory->propertyPairs() ) {
    ofs << prop.first << "  " << dumpProp(prop.second) << std::endl;
  }

  ofs << std::endl << "SERVICES" << std::endl;
  for (const auto &s : m_svcmap ) dumpProperties( *s.first, ofs );

  ofs << std::endl << "ALGORITHMS" << std::endl;
  for (const auto & alg : m_algmap ) dumpProperties( *alg.first, ofs );

  ofs << std::endl << "ALGTOOLS" << std::endl;
  for (const auto&  tool : m_algtoolmap ) dumpProperties( *tool.first, ofs );

}

void HistorySvc::dumpProperties ( const IService &  svc, std::ofstream &  ofs  ) const

private

Definition at line 669 of file HistorySvc.cpp.

                                                                      {

  ServiceHistory *hist = getServiceHistory( svc );

  if ( !hist ) return;

  for (auto &prop: hist->properties()) {
    ofs << svc.name() << "  " << dumpProp(prop) << std::endl;
  }

}

void HistorySvc::dumpProperties ( const Algorithm &  alg, std::ofstream &  ofs  ) const

private

Definition at line 364 of file HistorySvc.cpp.

                                                                       {

  AlgorithmHistory *hist = getAlgHistory( alg );

  if ( !hist ) {
    return;
  }

  PropertyList::const_iterator itr;
  for (auto prop: hist->properties()) {
    ofs << alg.name() << "  " << dumpProp(prop) << std::endl;
  }

}

void HistorySvc::dumpProperties ( const IAlgTool &  alg, std::ofstream &  ofs  ) const

private

Definition at line 744 of file HistorySvc.cpp.

                                                                      {

  AlgToolHistory *hist = getAlgToolHistory( alg );

  if ( !hist ) return;

  for (auto& prop: hist->properties()) {
    ofs << alg.name() << "  " << dumpProp(prop) << std::endl;
  }

}

void HistorySvc::dumpState ( std::ofstream &  ofs ) const

private

Definition at line 817 of file HistorySvc.cpp.

                                            {


  if(m_outputFileTypeXML) {
    //xml header
    ofs << "<?xml version=\"1.0\" ?> " << std::endl;
    ofs << "<!--Test-xml-->" << std::endl;
    ofs << "<SETUP>" << std::endl;
    ofs << "  <GLOBAL>" << std::endl;
  } else {
    ofs << "GLOBAL" << std::endl;
  }

  std::string client_currently_open = "start";
  for (auto& item: m_jobHistory->propertyPairs()) {
    // client is the name of the component of the current property
    const std::string& client = item.first;
    const Property* prp = item.second;

    if (m_outputFileTypeXML) {

      if (client != client_currently_open) {
    if(client_currently_open!="start") ofs << "    </COMPONENT>" << endl;
    ofs << "    <COMPONENT name=\""
        << client << "\" class=\"undefined\">" << std::endl;
      }
    } else {
      ofs << client << "  ";
    }

    ofs << dumpProp(prp,m_outputFileTypeXML,6) << endl;

    client_currently_open = client;

    if (m_outputFileTypeXML)
  ofs << "    </COMPONENT>" << endl;
  }


  if(m_outputFileTypeXML) {
    ofs << "</GLOBAL>" << endl << "<SERVICES>" << endl;
  } else {
    ofs << "SERVICES" << std::endl;
  }

  for (auto& item: m_svcmap) {
    const IService* svc = item.first;
    dumpState(svc, ofs);
  }

  if(m_outputFileTypeXML) {
    ofs << "</SERVICES>" << endl << "<ALGORITHMS> " << endl;
  } else {
    ofs << "ALGORITHMS" << std::endl;
  }

  for (auto& item: m_algmap) {
    const Algorithm* alg = item.first;
    dumpState(alg, ofs);
  }


  if(m_outputFileTypeXML) {
    ofs << "</ALGORITHMS>" << endl << "<ALGTOOLS> " << endl;
  } else {
    ofs << "ALGTOOLS" << std::endl;
  }

  for (auto& item: m_algtoolmap) {
    const AlgTool* algtool = item.first;
    dumpState(algtool, ofs);
  }

  if(m_outputFileTypeXML) {
    ofs << "</ALGTOOLS>" << endl << "</SETUP>" << endl;
  }

}

void HistorySvc::dumpState ( const INamedInterface *  in, std::ofstream &  ofs  ) const

private

Definition at line 899 of file HistorySvc.cpp.

                                                                       {

  HistoryObj *hist = nullptr;
  IVersHistoryObj *vhist = nullptr;

  const IService*  is = nullptr;
  const Algorithm* ia = nullptr;
  const IAlgTool*  it = nullptr;
  if ( (is=dynamic_cast<const IService*>(in)) != nullptr) {
    ON_VERBOSE
      m_log << MSG::VERBOSE << in->name() << " is Service" << endmsg;
    ServiceHistory* o = getServiceHistory( *is );
    hist = dynamic_cast<HistoryObj*>( o );
    vhist = dynamic_cast<IVersHistoryObj*>( o );
  } else if ( (ia = dynamic_cast<const Algorithm*>(in)) != nullptr ) {
    ON_VERBOSE
      m_log << MSG::VERBOSE << in->name() << " is Alg" << endmsg;
    AlgorithmHistory *o = getAlgHistory( *ia );
    hist = dynamic_cast<HistoryObj*>( o );
    vhist = dynamic_cast<IVersHistoryObj*>( o );
  } else if ( (it = dynamic_cast<const IAlgTool*>(in)) != nullptr ) {
    ON_VERBOSE
      m_log << MSG::VERBOSE << in->name() << " is AlgTool" << endmsg;
    AlgToolHistory *o = getAlgToolHistory( *it );
    hist = dynamic_cast<HistoryObj*>( o );
    vhist = dynamic_cast<IVersHistoryObj*>( o );
  } else {
    m_log << MSG::ERROR
      << "Could not dcast interface to accepted History Obj type for "
      << in->name() << endmsg;
    return;
  }

  if ( !hist || !vhist ) {
    m_log << MSG::ERROR << "Could not dcast recognized object to HistoryObj or IVersHistoryObj. This should never happen."
      << endmsg;
    return;
  }

  if (m_outputFileTypeXML) {
    hist->dump(ofs,true);
  } else {
    ofs << ">> " << vhist->name() << endl << *hist << endl;
  }

}

StatusCode HistorySvc::finalize ( )

virtual

Definition at line 298 of file HistorySvc.cpp.

                                {

  ON_VERBOSE
    m_log << MSG::VERBOSE << "HistorySvc::finalize()" << endmsg;

  clearState();

  StatusCode status = Service::finalize();

  if ( status.isSuccess() )
    m_log << MSG::INFO << "Service finalised successfully" << endmsg;

  return status;

}

AlgorithmHistory * HistorySvc::getAlgHistory ( const Algorithm &  alg ) const

virtual

Definition at line 381 of file HistorySvc.cpp.

                                                    {

  auto itr = m_algmap.find( &alg );
  if ( itr == m_algmap.end() ) {
    m_log << MSG::WARNING << "Algorithm " << alg.name() << " not registered"
          << endmsg;
    return nullptr;
  }
  return itr->second;
}

void HistorySvc::getAlgHistory ( std::set< AlgorithmHistory * > &  algs ) const

virtual

Definition at line 394 of file HistorySvc.cpp.

                                                               {
  map_to_set(m_algmap, algs);
}

AlgToolHistory * HistorySvc::getAlgToolHistory ( const IAlgTool &  alg ) const

virtual

Definition at line 759 of file HistorySvc.cpp.

                                                       {

  const AlgTool *palg = dynamic_cast<const AlgTool*>(&alg);
  auto itr = m_algtoolmap.find(palg);
  if ( itr == m_algtoolmap.end() ) {
    m_log << MSG::WARNING << "AlgTool " << alg.name() << " not registered"
          << endmsg;
    return nullptr;
  }
  return itr->second;

}

void HistorySvc::getAlgToolHistory ( std::set< AlgToolHistory * > &  algs ) const

virtual

Definition at line 775 of file HistorySvc.cpp.

                                                                 {
  map_to_set(m_algtoolmap, algs);
}

IAlgorithm * HistorySvc::getCurrentIAlg ( ) const

private

Definition at line 484 of file HistorySvc.cpp.

                                 {
  if ( p_algCtxSvc ) return p_algCtxSvc->currentAlg();
  m_log << MSG::WARNING << "trying to create DataHistoryObj before "
    << "HistorySvc has been initialized" << endmsg;
  return nullptr;
}

DataHistory * HistorySvc::getDataHistory ( const CLID &  id, const std::string &  key, const std::string &  store  ) const

virtual

Definition at line 566 of file HistorySvc.cpp.

                                         {

  DHH dhh(id,key);

  auto mitr = m_datMap.equal_range(dhh);
  return (mitr.first != mitr.second) ? mitr.first->second
                                     : nullptr ;

}

int HistorySvc::getDataHistory ( const CLID &  id, const std::string &  key, const std::string &  storeName, std::list< DataHistory * > &  dhlist  ) const

virtual

Definition at line 580 of file HistorySvc.cpp.

                                                    {

  DHH dhh(id,key);

  int n(0);

  auto mitr = m_datMap.equal_range(dhh);
  for (auto itr=mitr.first; itr != mitr.second; ++itr) {
    dhlist.push_back(itr->second);
    ++n;
  }
  return n;

}

JobHistory * HistorySvc::getJobHistory ( ) const

virtual

Definition at line 476 of file HistorySvc.cpp.

                                {

  return m_jobHistory.get();

}

ServiceHistory * HistorySvc::getServiceHistory ( const IService &  svc ) const

virtual

Definition at line 632 of file HistorySvc.cpp.

                                                       {

  const IService *psvc = &svc;
  auto itr = m_svcmap.find(psvc);
  if ( itr != m_svcmap.end() ) return itr->second;
  
  m_log << MSG::WARNING << "Service " << svc.name() << " not registered"
        << endmsg;
  return nullptr;
}

void HistorySvc::getServiceHistory ( std::set< ServiceHistory * > &  svcs ) const

virtual

Definition at line 645 of file HistorySvc.cpp.

                                                                 {
  map_to_set(m_svcmap, svcs);
}

void HistorySvc::handle ( const Incident &  inc )

virtual

Definition at line 782 of file HistorySvc.cpp.

                                           {

  if (incident.type() == IncidentType::BeginEvent) {
    if (captureState().isFailure()) {
      m_log << MSG::WARNING << "Error capturing state." << endl
            << "Will try again at next BeginEvent incident" << endmsg;
    }
  }

}

StatusCode HistorySvc::initialize ( )

virtual

Definition at line 127 of file HistorySvc.cpp.

                                  {

  StatusCode status = Service::initialize();
  m_log.setLevel( m_outputLevel.value() );

  if (status.isFailure()) {

    ON_DEBUG
      m_log << MSG::DEBUG << "Failed to initialize the base class (Service)"
        << endmsg;
    return status;
  }

  ON_DEBUG
    m_log << MSG::DEBUG << "Initializing HistorySvc" << endmsg;

  if (!m_activate) return StatusCode::SUCCESS;

  static const bool CREATEIF(true);

  if ( service("AlgContextSvc",p_algCtxSvc,CREATEIF).isFailure() ) {
    m_log << MSG::ERROR << "unable to get the AlgContextSvc" << endmsg;
    return StatusCode::FAILURE;
  }

  if (service("IncidentSvc", m_incidentSvc, CREATEIF).isFailure()) {
    m_log << MSG::ERROR << "unable to get the IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }

  // create a weak dependency on the ToolSvc, so that it doesn't get deleted
  // before we're done with it in finalize
  m_toolSvc = serviceLocator()->service("ToolSvc");
  if (! m_toolSvc)  {
    m_log << MSG::ERROR << "could not retrieve the ToolSvc handle !"
      << endmsg;
    return StatusCode::FAILURE;
  }

  // add listener to be triggered by first BeginEvent with low priority
  // so it gets called first
  const bool rethrow = false;
  const bool oneShot = true; // make the listener called only once
  m_incidentSvc->addListener(this,IncidentType::BeginEvent,
                 std::numeric_limits<long>::min(),rethrow,oneShot);

  m_outputFileTypeXML =  ba::iends_with( m_outputFile, ".xml");
  ON_DEBUG if (m_outputFileTypeXML ) {
    m_log << MSG::DEBUG << "output format is XML" << endmsg;
  }

  m_isInitialized = true;

  return StatusCode::SUCCESS;
}

StatusCode HistorySvc::listProperties ( ) const

virtual

Definition at line 412 of file HistorySvc.cpp.

                                 {

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for all Algorithms (" << m_algmap.size()
    << ")" << endmsg;

  for (auto& alg: m_algmap) {
    listProperties(*alg.first).ignore();
  }

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for all AlgTools (" << m_algtoolmap.size()
    << ")" << endmsg;

  for (auto& algtool: m_algtoolmap) {
    ON_DEBUG
      m_log << MSG::DEBUG << " --> " << algtool.second->algtool_name() << endmsg;
    listProperties(*algtool.first).ignore();
  }

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for all Services (" << m_svcmap.size()
    << ")" << endmsg;

  for (auto& svc: m_svcmap) {
    listProperties(*svc.first).ignore();
  }

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for Job";
  m_log.resetColor();

  m_log << std::endl << *m_jobHistory << endmsg;

  return StatusCode(StatusCode::SUCCESS,true);

}

StatusCode HistorySvc::listProperties ( const IService &  svc ) const

virtual

Definition at line 652 of file HistorySvc.cpp.

                                                    {

  m_log << MSG::INFO << "Dumping properties for " << svc.name() << endl;

  ServiceHistory *hist = getServiceHistory( svc );

  if ( !hist ) return StatusCode::FAILURE;

  m_log << MSG::INFO << svc.name() << " --> " << endl << *hist << endmsg;

  return StatusCode(StatusCode::SUCCESS,true);

}

StatusCode HistorySvc::listProperties ( const Algorithm &  alg ) const

virtual

Definition at line 346 of file HistorySvc.cpp.

                                                     {

  m_log << MSG::INFO << "Dumping properties for " << alg.name() << endl;

  AlgorithmHistory *hist = getAlgHistory( alg );

  if ( !hist ) {
    return StatusCode::FAILURE;
  }

  m_log << MSG::INFO << alg.name() << " --> " << endl << *hist << endmsg;

  return StatusCode(StatusCode::SUCCESS,true);

}

StatusCode HistorySvc::listProperties ( const IAlgTool &  alg ) const

virtual

Definition at line 727 of file HistorySvc.cpp.

                                                    {

  m_log << MSG::INFO << "Dumping properties for " << alg.name() << endl;

  AlgToolHistory *hist = getAlgToolHistory( alg );

  if ( !hist ) return StatusCode::FAILURE;


  m_log << MSG::INFO << alg.name() << " --> " << endl << *hist << endmsg;

  return StatusCode::SUCCESS;

}

StatusCode HistorySvc::registerAlg ( const Algorithm &  alg )

virtual

Definition at line 320 of file HistorySvc.cpp.

                                            {

  JobHistory *job = getJobHistory();
  if (m_algmap.find(&alg) != m_algmap.end()) {
    m_log << MSG::WARNING << "Algorithm " << alg.name()
      << " already registered with HistorySvc" << endmsg;
    return StatusCode::SUCCESS;
  }

  (const_cast<Algorithm*>(&alg))->addRef();

  m_algmap[&alg] = new AlgorithmHistory(alg, job);

  ON_DEBUG {
    m_log << MSG::DEBUG << "Registering algorithm: ";
    m_log.setColor(MSG::CYAN);
    m_log << alg.name() << endmsg;
    m_log.resetColor();
  }

  return StatusCode(StatusCode::SUCCESS,true);

}

StatusCode HistorySvc::registerAlgTool ( const IAlgTool &  ialg )

virtual

Definition at line 684 of file HistorySvc.cpp.

                                                {

  if (! m_isInitialized) {
    if ( !p_algCtxSvc ) {
      if ( service("AlgContextSvc",p_algCtxSvc,true).isFailure() ) {
    m_log << MSG::ERROR << "unable to get the AlgContextSvc" << endmsg;
    return StatusCode::FAILURE;
      }
    }
    m_ialgtools.insert(&ialg);
    return StatusCode::SUCCESS;
  }

  const AlgTool *alg = dynamic_cast<const AlgTool*>( &ialg );
  if ( !alg ) {
    m_log << MSG::ERROR << "Could not dcast IAlgTool \"" << ialg.name()
      << "\" to an AlgTool" << endmsg;
    return StatusCode::FAILURE;
  }

  if (m_algtoolmap.find(alg) != m_algtoolmap.end()) {
    m_log << MSG::WARNING << "AlgTool " << ialg.name()
      << " already registered in HistorySvc" << endmsg;
    return StatusCode::SUCCESS;
  }

  const JobHistory *job = getJobHistory();
  m_algtoolmap[alg] = new AlgToolHistory(*alg, job);

  if (m_log.level() <= MSG::DEBUG) {
    m_log << MSG::DEBUG << "Registering algtool: ";
    m_log.setColor(MSG::CYAN);
    m_log << alg->name() << endmsg;
    m_log.resetColor();
  }

  return StatusCode::SUCCESS;

}

StatusCode HistorySvc::registerDataHistory ( const CLID &  id, const std::string &  key, const std::string &  store  )

virtual

Definition at line 529 of file HistorySvc.cpp.

                                            {

  DHH dhh(id,key);

  auto boundaries = m_datMap.equal_range(dhh);
  auto match = boundaries.second;

  if (boundaries.first != boundaries.second) {
    // there is something in the map, let's look for the specific entry

    std::string algName;
    IAlgorithm *ialg = getCurrentIAlg();
    if (ialg) {
      algName = ialg->name();
    } else {
      algName = "UNKNOWN";
    }

    match = std::find_if(boundaries.first, boundaries.second,
                         [&algName](decltype(boundaries)::first_type::reference p) -> bool {
      return p.second->algorithmHistory()->algorithm_name() == algName;
    });
  }

  if (match == boundaries.second) { // not found, crete the entry
    DataHistory *dh = createDataHistoryObj(id, key, storeName);
    m_datMap.insert(pair<DHH, DataHistory*>(dhh,dh));
  }

  return StatusCode::SUCCESS;

}

StatusCode HistorySvc::registerJob ( )

virtual

Definition at line 401 of file HistorySvc.cpp.

                        {


  return StatusCode(StatusCode::SUCCESS,true);


}

StatusCode HistorySvc::registerSvc ( const IService &  svc )

virtual

Definition at line 600 of file HistorySvc.cpp.

                                           {

  if ( svc.name() == "HistoryStore" ) {
    //    m_log << MSG::WARNING << "not registering store" << endmsg;
    return StatusCode(StatusCode::SUCCESS,true);
  }

  JobHistory *job = getJobHistory();
  const IService* psvc = &svc;
  auto itr = m_svcmap.find(psvc);
  if (itr == m_svcmap.end()) {

    if (m_log.level() <= MSG::DEBUG) {
      m_log << MSG::DEBUG << "Registering Service: ";
      m_log.setColor(MSG::CYAN);
      m_log << svc.name() << endmsg;
    }

    m_svcmap[psvc] = new ServiceHistory(&svc, job);

    (const_cast<IService*>(psvc))->addRef();

  }

  m_log.resetColor();
  return StatusCode(StatusCode::SUCCESS,true);

}

StatusCode HistorySvc::reinitialize ( )

virtual

Definition at line 91 of file HistorySvc.cpp.

                                    {

  clearState();
  m_state = Gaudi::StateMachine::OFFLINE;
  return initialize();

}

StatusCode HistorySvc::stop ( )

virtual

Definition at line 271 of file HistorySvc.cpp.

                            {

  if (!m_activate) return StatusCode::SUCCESS;

  if (m_dump) {
    listProperties().ignore();
  }

  if (!m_outputFile.empty()) {
    std::ofstream ofs(m_outputFile);
    if (!ofs) {
      m_log << MSG::ERROR << "Unable to open output file \"m_outputFile\""
        << endmsg;
    } else {
      //      dumpProperties(ofs);
      dumpState(ofs);
    }
  }

  clearState();

  return StatusCode::SUCCESS;

}

Member Data Documentation

bool HistorySvc::m_activate = true

private

Definition at line 104 of file HistorySvc.h.

std::map<const Algorithm*, AlgorithmHistory*> HistorySvc::m_algmap

private

Definition at line 108 of file HistorySvc.h.

std::map<const AlgTool*, AlgToolHistory*> HistorySvc::m_algtoolmap

private

Definition at line 111 of file HistorySvc.h.

std::multimap<DHH, DataHistory*> HistorySvc::m_datMap

private

Definition at line 114 of file HistorySvc.h.

bool HistorySvc::m_dump = false

private

Definition at line 103 of file HistorySvc.h.

std::set<const IAlgTool*> HistorySvc::m_ialgtools

private

Definition at line 110 of file HistorySvc.h.

IIncidentSvc* HistorySvc::m_incidentSvc = nullptr

private

Definition at line 135 of file HistorySvc.h.

bool HistorySvc::m_isInitialized = false

private

Definition at line 102 of file HistorySvc.h.

std::unique_ptr<JobHistory> HistorySvc::m_jobHistory

private

Definition at line 118 of file HistorySvc.h.

MsgStream HistorySvc::m_log

mutableprivate

Definition at line 138 of file HistorySvc.h.

std::string HistorySvc::m_outputFile

private

Definition at line 120 of file HistorySvc.h.

bool HistorySvc::m_outputFileTypeXML = false

private

Definition at line 139 of file HistorySvc.h.

std::map<const IService*, ServiceHistory*> HistorySvc::m_svcmap

private

Definition at line 112 of file HistorySvc.h.

SmartIF<IToolSvc> HistorySvc::m_toolSvc

private

Definition at line 136 of file HistorySvc.h.

IAlgContextSvc* HistorySvc::p_algCtxSvc = nullptr

private

Definition at line 106 of file HistorySvc.h.

---

The documentation for this class was generated from the following files:

• GaudiMonitor/src/HistorySvc.h
• GaudiMonitor/src/HistorySvc.cpp