OpMonManager.hpp

Go to the documentation of this file.

 
#ifndef OPMONLIB_INCLUDE_OPMONLIB_OPMONMANAGER_HPP_
#define OPMONLIB_INCLUDE_OPMONLIB_OPMONMANAGER_HPP_
 
#include <cstddef>
#include <thread>
 
#include "opmonlib/MonitorableObject.hpp"
#include "opmonlib/Utils.hpp"
 
#include "confmodel/OpMonConf.hpp"
#include "logging/Logging.hpp" // NOTE: if ISSUES ARE DECLARED BEFORE include logging/Logging.hpp, TLOG_DEBUG<<issue wont work.
 
namespace dunedaq {
 
ERS_DECLARE_ISSUE(opmonlib,
                  ThreadNameTooLong,
                  "The name " << name << " is too long for a thread name",
                  ((std::string)name))
 
ERS_DECLARE_ISSUE(opmonlib, MonitoringThreadNotSet, "Monitoring thread not set", ERS_EMPTY)
 
ERS_DECLARE_ISSUE(opmonlib, FailedMonitoringThread, "Monitoring thread failed to start", ERS_EMPTY)
 
ERS_DECLARE_ISSUE(opmonlib, MissingConfiguration, "Confiration is not set", ERS_EMPTY)
}
 
namespace dunedaq::opmonlib {
 
class OpMonManager : protected MonitorableObject
{
 
  friend class TestOpMonManager;
 
public:
  /*
   * Construtor expected to be used for standard operations,
   * yet, general developers should not concern themselves with this as the framework handles this for them
   */
  explicit OpMonManager(std::string session, std::string name, std::string opmon_facility_uri = "stdout")
    : OpMonManager(session, name, makeOpMonFacility(opmon_facility_uri, make_origin(session, name)))
  {
    ;
  }
 
  virtual ~OpMonManager() = default;
 
  using MonitorableObject::get_opmon_id;
  using MonitorableObject::get_opmon_level;
  using MonitorableObject::register_node;
  using MonitorableObject::set_opmon_level;
 
  // data collecting loop
  void start_monitoring();
  // The stop command is not necessary, although it is provided to facilitate complex object behaviour
  // The stop is invoked during the destruction of the thread
  // the method requires a valid configuration because the time period is taken from there
 
  void stop_monitoring();
  // on top of stopping the monitorin thread, this method will also join the thread
 
  void set_opmon_conf(const confmodel::OpMonConf* c)
  {
    m_cfg.store(c);
    set_opmon_level(m_cfg.load()->get_level());
  }
 
protected:
  using MonitorableObject::collect;
 
  // obtain the opmon facility
  auto get_opmon_facility() const { return m_facility.load(); }
 
  OpMonManager(std::string session, std::string name, facility_ptr_t);
 
  void run(std::stop_token); // function used by the jthread
 
private:
  std::jthread m_thread;
  std::atomic<const confmodel::OpMonConf*> m_cfg{ nullptr };
};
 
} // namespace dunedaq::opmonlib
 
#endif // OPMONLIB_INCLUDE_OPMONLIB_OPMONMANAGER_HPP_