LoggerConfigLoader.cpp

Go to the documentation of this file.

#include <Poco/Util/IniFileConfiguration.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Poco/AutoPtr.h>
#include <Poco/Logger.h>
#include <Poco/PatternFormatter.h>
#include <Poco/FormattingChannel.h>
#include <Poco/FileChannel.h>
#include <Poco/ConsoleChannel.h>
#include <Poco/Format.h>
#include <Poco/Path.h>

#include "LoggerConfigLoader.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
// constants using for initialization Poco::Logger
const std::string LoggerConfigLoader::sectionPatternFormatter = "PatternFormatter";
const std::string LoggerConfigLoader::sectionFileChannel = "FileChannel";
const std::string LoggerConfigLoader::sectionLogger = "Logger";
const std::string LoggerConfigLoader::delimiter = "-";
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
LoggerConfigLoader::LoggerConfigLoader(const std::string& nodeName_, const Poco::Util::IniFileConfiguration::Keys& loggers_, const std::string& configFileName)
: nodeName(nodeName_), errorMsg(""), _isError(false), loggers(loggers_)
{
  if (!configFileName.empty())
    loadConfig(configFileName);
}
//-----------------------------------------------------------------------------
LoggerConfigLoader::LoggerConfigLoader(const std::string& nodeName_, const std::string& configFileName)
: nodeName(nodeName_), errorMsg(""), _isError(false), loggers()
{
  if (!configFileName.empty())
    loadConfig(configFileName);
}
//-----------------------------------------------------------------------------
LoggerConfigLoader::~LoggerConfigLoader(void)
{
}
//-----------------------------------------------------------------------------
void LoggerConfigLoader::defaultInitialization(void)
{
  Poco::AutoPtr<Poco::PatternFormatter> pPatternFormatter(new Poco::PatternFormatter("%Y-%m-%d %H:%M:%S.%i %N[%P]:%s:%q:%t"));
  if (pPatternFormatter)
  {
    pPatternFormatter->setProperty(Poco::PatternFormatter::PROP_TIMES, "local");
    Poco::AutoPtr<Poco::FormattingChannel> pChannel = new Poco::FormattingChannel(pPatternFormatter);
    if (pChannel)
    {
      Poco::AutoPtr<Poco::ConsoleChannel> pCons(new Poco::ConsoleChannel());
      pChannel->setChannel(pCons);
      pChannel->open();
      Poco::Logger::root().setChannel(pChannel);
      Poco::Logger::root().setLevel("information");
      Poco::Logger::root().information("Initialization console logger");
    }
  }
}
//-----------------------------------------------------------------------------
bool LoggerConfigLoader::loadConfig(const std::string& configFileName)
{
  _isError = true;
  errorMsg.clear();
  try
  {
    if (configFileName.empty())
      defaultInitialization();
    else
    {
      Poco::AutoPtr<Poco::Util::IniFileConfiguration> pConf(new Poco::Util::IniFileConfiguration(configFileName));

      // getting names all loggers
      Poco::Util::IniFileConfiguration::Keys loggerNames;
      getLoggers(*pConf, loggerNames);

      checkExistSection(*pConf, loggerNames);

      // initialization all found loggers
      for (size_t i=0;i<loggers.size();++i)
      {
        loggerInitialization(*pConf, loggers[i]);
      }
    }
    _isError = false;
  }
  catch(Poco::SyntaxException& e)
  {
    errorMsg = e.displayText();
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.displayText();
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
void LoggerConfigLoader::loadSection(Poco::Util::IniFileConfiguration& iniFileConfiguration,
    const std::string& sectionName,
    Poco::Configurable& configurable) throw (Poco::Exception)
{
  Poco::Util::IniFileConfiguration::Keys keys;
  iniFileConfiguration.keys(sectionName, keys);

  for (size_t i=0;i<keys.size();++i)
  {
    std::string parameterName = sectionName+"."+keys[i];
    if (iniFileConfiguration.has(parameterName))
    {
      std::string parameterValue = iniFileConfiguration.getString(parameterName);
      if (keys[i]=="path")
      {
        parameterValue = Poco::format(parameterValue, nodeName);
        parameterValue = Poco::Path(parameterValue).absolute().toString();
      }
      configurable.setProperty(keys[i], parameterValue);
    }
  }
}
//-----------------------------------------------------------------------------
void LoggerConfigLoader::loggerInitialization(Poco::Util::IniFileConfiguration& iniFileConfiguration, const std::string& loggerName) throw (Poco::Exception)
{
  Poco::AutoPtr<Poco::PatternFormatter> pPatternFormatter(new Poco::PatternFormatter());
  if (pPatternFormatter)
  {
    loadSection(iniFileConfiguration, getLoggerSectionName(LoggerConfigLoader::sectionPatternFormatter, loggerName), *pPatternFormatter);

    Poco::AutoPtr<Poco::FormattingChannel> pChannel = new Poco::FormattingChannel(pPatternFormatter);
    if (pChannel)
    {
      Poco::AutoPtr<Poco::FileChannel> pFileChannel = new Poco::FileChannel();
      pChannel->setChannel(pFileChannel);

      loadSection(iniFileConfiguration, getLoggerSectionName(LoggerConfigLoader::sectionFileChannel, loggerName), *pFileChannel);

      Poco::Logger& logger = Poco::Logger::get(loggerName);
      logger.setChannel(pChannel);
      pChannel->open();

      loadSection(iniFileConfiguration, getLoggerSectionName(LoggerConfigLoader::sectionLogger, loggerName), logger);
    }
  }
}
//-----------------------------------------------------------------------------
std::string LoggerConfigLoader::getLoggerSectionName(const std::string& sectionName, const std::string& loggerName)
{
  std::string loggerSectionName(sectionName);

  if (!loggerName.empty())
    loggerSectionName.append(LoggerConfigLoader::delimiter).append(loggerName);

  return loggerSectionName;
}
//-----------------------------------------------------------------------------
void LoggerConfigLoader::getLoggers(Poco::Util::IniFileConfiguration& iniFileConfiguration, Poco::Util::IniFileConfiguration::Keys& loggerNames)
{
  loggerNames.clear();
  Poco::Util::IniFileConfiguration::Keys keys;
  iniFileConfiguration.keys(keys);
  for (size_t i=0;i<keys.size();++i)
  {
    size_t pos = keys[i].find(LoggerConfigLoader::sectionLogger);
    if (pos!=std::string::npos)
    {
      std::string sectionName = keys[i].substr();
      sectionName.erase(pos, LoggerConfigLoader::sectionLogger.length());
      pos = sectionName.find(LoggerConfigLoader::delimiter);
      if (pos!=std::string::npos)
        sectionName.erase(pos, LoggerConfigLoader::delimiter.length());

      loggerNames.push_back(sectionName);
    }
  }
}
//-----------------------------------------------------------------------------
void LoggerConfigLoader::checkExistSection(Poco::Util::IniFileConfiguration& iniFileConfiguration,
    const Poco::Util::IniFileConfiguration::Keys& loggerNames) throw (Poco::Exception)
{
  for (const std::string logger : loggers)
  {
    bool found = false;
    for (const std::string loggerName : loggerNames)
    {
      if (logger == loggerName)
      {
        found = true;
        break;
      }
    }
    if (!found)
      throw Poco::Exception("Not found mandatory logger name: '"+logger+"'");
  }

  Poco::Util::IniFileConfiguration::Keys sections;
  iniFileConfiguration.keys(sections);

  for (const std::string loggerName : loggerNames)
  {
    checkExistSection(sections, LoggerConfigLoader::getLoggerSectionName(sectionPatternFormatter, loggerName));
    checkExistSection(sections, LoggerConfigLoader::getLoggerSectionName(sectionFileChannel, loggerName));
    checkExistSection(sections, LoggerConfigLoader::getLoggerSectionName(sectionLogger, loggerName));
  }
}
//-----------------------------------------------------------------------------
void LoggerConfigLoader::checkExistSection(const Poco::Util::IniFileConfiguration::Keys& sections,
    const std::string& sectionName) throw (Poco::Exception)
{
  bool found = false;
  for (const std::string section : sections)
  {
    if (section == sectionName)
    {
      found = true;
      break;
    }
  }
  if (!found)
    throw Poco::Exception("Not found mandatory section name: '"+sectionName+"'");
}
//-----------------------------------------------------------------------------
unsigned int LoggerConfigLoader::getDebugLevel(void)
{
  return static_cast<unsigned int>(Poco::Logger::root().getLevel());
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE