DRCEResourceLimitsChecker.cpp

Go to the documentation of this file.

#include <string.h>
#include <Poco/Logger.h>

#include "DRCEResourceExtractor.hpp"
#include "DRCEResourceLimitsChecker.hpp"
#include "DRCEMessageConst.hpp"
#include "DRCEError.hpp"
#include "DRCEReadProcessData.hpp"

namespace HCE
{
namespace drce
{

//-----------------------------------------------------------------------------
DRCEResourceLimitsChecker::DRCEResourceLimitsChecker(CustomMessage& message_)
: message(message_)
{
}
//-----------------------------------------------------------------------------
void DRCEResourceLimitsChecker::checkLimits(const ResourceLimits& resourceLimit) throw (Poco::Exception)
{
  if ((resourceLimit.cpuMax > 0) || (resourceLimit.iowaitMax > 0))
  {
    if (resourceLimit.cpuMax > 0)
    {
      if (resourceLimit.cpuMax < HCE::drce::ResourceUsageExtractor::getInstance().getCpuUsageExtractor().getCpuUsage())
        throw Poco::Exception(message(message_const::EXCEEDED_CPU_LOAD)+
            message(message_const::PRESENT_LOADING, HCE::drce::ResourceUsageExtractor::getInstance().getCpuUsageExtractor().getCpuUsage())+" %",
            ERROR_EXCEEDED_RESOURCE_LIMITS);
    }

    if (resourceLimit.iowaitMax > 0)
    {
      if (resourceLimit.iowaitMax < HCE::drce::ResourceUsageExtractor::getInstance().getCpuUsageExtractor().getIOWait())
        throw Poco::Exception(message(message_const::EXCEEDED_IOWAIT_LOAD)+
            message(message_const::PRESENT_LOADING, HCE::drce::ResourceUsageExtractor::getInstance().getCpuUsageExtractor().getIOWait())+" %",
            ERROR_EXCEEDED_RESOURCE_LIMITS);
    }
  }

  if (resourceLimit.diskFree > 0 || resourceLimit.diskFreeMin)
  {
    std::stringstream outMsg;
    outMsg << " resourceLimit.diskFreeMin = " << resourceLimit.diskFreeMin
        << " diskSpaceExtractor.getDiskFree() = " << HCE::drce::ResourceUsageExtractor::getInstance().getDiskSpaceExtractor().getDiskFree()
        << "\nresourceLimit.diskFree = " << resourceLimit.diskFree
        << " diskSpaceExtractor.getDiskFreePercent() = " << HCE::drce::ResourceUsageExtractor::getInstance().getDiskSpaceExtractor().getDiskFreePercent();
    Poco::Logger::root().log(Poco::Message(drce_const::moduleName, outMsg.str(), Poco::Message::Priority::PRIO_TRACE));

    if (resourceLimit.diskFreeMin > HCE::drce::ResourceUsageExtractor::getInstance().getDiskSpaceExtractor().getDiskFree())
      throw Poco::Exception(message(message_const::EXCEEDED_DISK_SPACE)+
          message(message_const::FREE, HCE::drce::ResourceUsageExtractor::getInstance().getDiskSpaceExtractor().getDiskFree())+
          message(message_const::BYTES), ERROR_EXCEEDED_RESOURCE_LIMITS);

    if (resourceLimit.diskFree > HCE::drce::ResourceUsageExtractor::getInstance().getDiskSpaceExtractor().getDiskFreePercent())
      throw Poco::Exception(message(message_const::EXCEEDED_DISK_SPACE)+
          message(message_const::FREE, HCE::drce::ResourceUsageExtractor::getInstance().getDiskSpaceExtractor().getDiskFreePercent())+
          message(message_const::PERCENTS), ERROR_EXCEEDED_RESOURCE_LIMITS);
  }

  if (resourceLimit.rramFree > 0.0 || resourceLimit.rramFreeMin || resourceLimit.vramFree > 0.0 || resourceLimit.vramFreeMin)
  {
    std::stringstream outMsg;
    outMsg << " resourceLimit.rramFreeMin = " << resourceLimit.rramFreeMin
          << " memoryExtractor.getRramFree() = " << HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getRramFree()
          << "\nresourceLimit.rramFree = " << resourceLimit.rramFree
          << " memoryExtractor.getRramFreePercent() = " << HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getRramFreePercent()
          << "\nresourceLimit.vramFreeMin = " << resourceLimit.vramFreeMin
          << " memoryExtractor.getVramFree() = " << HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getVramFree()
          << "\nresourceLimit.vramFree = " << resourceLimit.vramFree
          << " memoryExtractor.getVramFreePercent() = " << HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getVramFreePercent();
    Poco::Logger::root().log(Poco::Message(drce_const::moduleName, outMsg.str(), Poco::Message::Priority::PRIO_TRACE));

    if (resourceLimit.rramFreeMin > HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getRramFree())
      throw Poco::Exception(message(message_const::EXCEEDED_RESOURCE_RAM)+
          message(message_const::FREE, HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getRramFree())+
          message(message_const::BYTES), ERROR_EXCEEDED_RESOURCE_LIMITS);

    if (resourceLimit.rramFree > HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getRramFreePercent())
      throw Poco::Exception(message(message_const::EXCEEDED_RESOURCE_RAM)+
          message(message_const::FREE, HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getRramFreePercent())+
          message(message_const::PERCENTS), ERROR_EXCEEDED_RESOURCE_LIMITS);

    if (resourceLimit.vramFreeMin > HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getVramFree())
      throw Poco::Exception(message(message_const::EXCEEDED_VIRTUAL_RAM)+
          message(message_const::FREE, HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getVramFree())+
          message(message_const::BYTES), ERROR_EXCEEDED_RESOURCE_LIMITS);

    if (resourceLimit.vramFree > HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getVramFreePercent())
      throw Poco::Exception(message(message_const::EXCEEDED_VIRTUAL_RAM)+
          message(message_const::FREE, HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getVramFreePercent())+
          message(message_const::PERCENTS), ERROR_EXCEEDED_RESOURCE_LIMITS);
  }

  if (resourceLimit.procMax || resourceLimit.threadsMax)
  {
    unsigned int processCount = 0;
    unsigned int threadsCount = 0;
    getUsingProcessAndThreads(processCount, threadsCount);

    std::stringstream outMsg;
    outMsg << " processCount = " << processCount << " threadsCount = " << threadsCount;
    Poco::Logger::root().log(Poco::Message(drce_const::moduleName, outMsg.str(), Poco::Message::Priority::PRIO_TRACE));

    if (resourceLimit.procMax)
    {
      if (resourceLimit.procMax < processCount)
        throw Poco::Exception(message(message_const::EXCEEDED_PROCESSES_COUNT)+
            message(message_const::USAGE, processCount), ERROR_EXCEEDED_RESOURCE_LIMITS);
    }

    if (resourceLimit.threadsMax)
    {
      if (resourceLimit.threadsMax < threadsCount)
        throw Poco::Exception(message(message_const::EXCEEDED_THREADS_COUNT)+
            message(message_const::USAGE, threadsCount), ERROR_EXCEEDED_RESOURCE_LIMITS);
    }
  }
}
//-----------------------------------------------------------------------------
void DRCEResourceLimitsChecker::getUsingProcessAndThreads(unsigned int& processCount, unsigned int& threadsCount)
{
  DRCEReadProcessData::getInstance().getProcessAndThreads(processCount, threadsCount);
}
//-----------------------------------------------------------------------------
void DRCEResourceLimitsChecker::checkLimits(const AsyncTasks& asyncTask, const ResourceUsageLimits& resourceUsageLimit) throw (Poco::Exception)
{
  HCE::TrimFormatter <double> trim;
  if (resourceUsageLimit.iowaitMax > 0)
  {
    if (resourceUsageLimit.iowaitMax < HCE::drce::ResourceUsageExtractor::getInstance().getCpuUsageExtractor().getIOWait())
      throw Poco::Exception(message(message_const::EXCEEDED_USAGE_IOWAIT_LOAD)+
          message(message_const::PRESENT_LOADING, HCE::drce::ResourceUsageExtractor::getInstance().getCpuUsageExtractor().getIOWait())+" %",
          ERROR_EXCEEDED_RESOURCE_LIMITS);
  }

  if (resourceUsageLimit.vramMax > 0 || resourceUsageLimit.rramMax > 0 || resourceUsageLimit.diskMax > 0 || resourceUsageLimit.diskMaxBytes > 0)
  {
    ProcessInfoExtractor::FieldsArray fieldsArray = ProcessInfoExtractor::extract(asyncTask);

    if (resourceUsageLimit.vramMax > 0)
    {
      double usedPercent = static_cast<double>(fieldsArray.vram * 100)/HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getVramUsed();

      if (resourceUsageLimit.vramMax < usedPercent)
        throw Poco::Exception(message(message_const::EXCEEDED_USAGE_VIRTUAL_RAM)+
            message(message_const::USAGE, trim(usedPercent))+
            message(message_const::PERCENTS), ERROR_EXCEEDED_RESOURCE_LIMITS);
    }

    if (resourceUsageLimit.rramMax > 0)
    {
      double usedPercent = static_cast<double>(fieldsArray.rram * 100)/HCE::drce::ResourceUsageExtractor::getInstance().getMemoryExtractor().getRramUsed();

      if (resourceUsageLimit.rramMax < usedPercent)
        throw Poco::Exception(message(message_const::EXCEEDED_USAGE_RESOURCE_RAM)+
            message(message_const::USAGE, trim(usedPercent))+
            message(message_const::PERCENTS), ERROR_EXCEEDED_RESOURCE_LIMITS);
    }

    if (resourceUsageLimit.diskMax > 0)
    {
      double usedPercent = static_cast<double>(fieldsArray.disk * 100)/HCE::drce::ResourceUsageExtractor::getInstance().getDiskSpaceExtractor().getDiskSize();

      if (resourceUsageLimit.diskMax < usedPercent)
        throw Poco::Exception(message(message_const::EXCEEDED_USAGE_DISK_SPACE)+
            message(message_const::USAGE, trim(usedPercent))+
            message(message_const::PERCENTS), ERROR_EXCEEDED_RESOURCE_LIMITS);
    }

    if (resourceUsageLimit.diskMaxBytes > 0)
    {
      if (resourceUsageLimit.diskMaxBytes < fieldsArray.disk)
        throw Poco::Exception(message(message_const::EXCEEDED_USAGE_DISK_SPACE)+
            message(message_const::USAGE, fieldsArray.disk)+
            message(message_const::BYTES), ERROR_EXCEEDED_RESOURCE_LIMITS);
    }
  }
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce 
} // end namespace HCE