messenger.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: no.
 
/*
 * messenger.cpp
 *
 *  Created on: Nov 3, 2015
 *      Author: Leonidas Georgopoulos
 */
 
#include "logging/Logging.hpp"
 
#include "dbe/messenger.hpp"
#include "dbe/messenger_proxy.hpp"
 
#include <cassert>
#include <map>
 
namespace dbe {
namespace interface {
namespace messenger {
 
//------------------------------------------------------------------------------------------
msglevels::t_str const msglevels::debug = "DEBUG";
msglevels::t_str const msglevels::info = "INFO";
msglevels::t_str const msglevels::note = "NOTE";
msglevels::t_str const msglevels::warn = "WARN";
msglevels::t_str const msglevels::error = "ERROR";
msglevels::t_str const msglevels::fail = "FAIL";
 
msglevels::t_levels const msglevels::all_levels = { debug, info, note, warn, error, fail };
// provides codes from message level type ( level -> code )
static std::map<qt::t_str const, messages const> codes = {
  { msglevels::info, messages::DEBUG }, { msglevels::info, messages::INFO },   { msglevels::note, messages::NOTE },
  { msglevels::warn, messages::WARN },  { msglevels::error, messages::ERROR }, { msglevels::fail, messages::FAIL }
};
 
// provides level types from code ( code->level)
static std::map<messages const, qt::t_str const> levels = {
  { messages::DEBUG, msglevels::debug }, { messages::INFO, msglevels::info },   { messages::NOTE, msglevels::note },
  { messages::WARN, msglevels::warn },   { messages::ERROR, msglevels::error }, { messages::FAIL, msglevels::fail }
};
 
// provides titles from level types
static std::map<qt::t_str const, qt::t_str const> titles = {
  { msglevels::debug, "Debug info" }, { msglevels::info, "Information" }, { msglevels::note, "Notice" },
  { msglevels::warn, "Warning" },     { msglevels::error, "Error" },      { msglevels::fail, "Failure" }
};
 
std::mutex qt::m_block;
std::atomic<bool> qt::m_batch_mode(false);
qt::t_batches qt::m_batches;
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
qt::post_ret_type
qt::post(t_str const& m, t_str const& l)
{
  std::lock_guard<std::mutex> lock(m_block);
 
  if (m_batch_mode) {
    merge_post(m, l);
  } else {
    direct_post(m, l);
  }
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
qt::post_ret_type
qt::direct_post(t_str const& m, t_str const& l)
{
  if (warn == l) {
    TLOG_DEBUG(0) << static_cast<int>(messages::WARN) << m;
    messenger_proxy::ref().warn(titles[warn], m);
  } else if (error == l) {
    TLOG_DEBUG(0) << static_cast<int>(messages::ERROR) << m;
    messenger_proxy::ref().error(titles[error], m);
  } else if (info == l) {
    TLOG_DEBUG(0) << static_cast<int>(messages::INFO) << m;
    messenger_proxy::ref().info(titles[info], m);
  } else if (fail == l) {
    TLOG_DEBUG(0) << static_cast<int>(messages::FAIL) << m;
    messenger_proxy::ref().fail(titles[fail], m);
  } else if (note == l) {
    TLOG_DEBUG(0) << static_cast<int>(messages::NOTE) << m;
    messenger_proxy::ref().fail(titles[note], m);
  } else if (debug == l) {
    TLOG_DEBUG(0) << static_cast<int>(messages::DEBUG) << m;
    messenger_proxy::ref().fail(titles[debug], m);
  }
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
qt::post_ret_type
qt::merge_post(t_str const& m, t_str const& l)
{
  auto codeit = codes.find(l);
  assert(codeit != codes.end());
  m_batches[static_cast<int>(codeit->second)].insert(m);
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
void
qt::purge()
{
  for (auto clevel = m_batches.begin(); clevel != m_batches.end(); ++clevel) {
    if (not clevel->empty()) {
      t_str merged("Summary of messages during batch mode");
 
      for (auto it = clevel->begin(); it != clevel->end();) {
        auto cnt = clevel->count(*it);
 
        t_str cmessage = *it;
        merged += t_str("\n\n") + cmessage + t_str("\n\n #Occurances=") + std::to_string(cnt);
 
        std::advance(it, cnt);
      }
 
      direct_post(merged, levels[static_cast<messages>(clevel - m_batches.begin())]);
      clevel->clear();
    }
  }
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
std::unique_ptr<batch_guard>
qt::batchmode()
{
  return std::unique_ptr<batch_guard>(new batch_guard());
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
batch_guard::~batch_guard()
{
  qt::m_batch_mode = false;
  qt::purge();
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
batch_guard::batch_guard()
{
  qt::m_batch_mode = true;
}
//------------------------------------------------------------------------------------------
 
} // namespace messenger
} /* namespace interface */
} /* namespace dbe */