DRCEResourceUsage.cpp

Go to the documentation of this file.

#include <sstream>
#include <iterator>
#include <algorithm>
#include <Poco/JSON/Object.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/JSON.h>
#include <Poco/JSON/Stringifier.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/JSONException.h>
#include <Poco/Dynamic/Var.h>

#include "DRCEResourceUsage.hpp"
#include "DRCEJsonMessageConst.hpp"
#include "DRCEMessageConst.hpp"
#include "DRCEError.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
ResourceUsage::ResourceUsage(void)
: cpu(0.0), iowait(0.0), vramUsed(0), vramUsedPercent(0.0), rramUsed(0), rramUsedPercent(0.0),
  diskUsed(0), diskUsedPercent(0.0), processes(0), processesPercent(0.0), threads(0), threadsPercent(0.0), loadAverage(0.0)
{
}
//-----------------------------------------------------------------------------
ResourceUsage::ResourceUsage(const ResourceUsage& rhs)
: cpu(0.0), iowait(0.0), vramUsed(0), vramUsedPercent(0.0), rramUsed(0), rramUsedPercent(0.0),
  diskUsed(0), diskUsedPercent(0.0), processes(0), processesPercent(0.0), threads(0), threadsPercent(0.0), loadAverage(0.0)
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
ResourceUsage::ResourceUsage(ResourceUsage&& rhs)
: cpu(0.0), iowait(0.0), vramUsed(0), vramUsedPercent(0.0), rramUsed(0), rramUsedPercent(0.0),
  diskUsed(0), diskUsedPercent(0.0), processes(0), processesPercent(0.0), threads(0), threadsPercent(0.0), loadAverage(0.0)
{
  (*this) = std::forward<ResourceUsage>(rhs);
}
//-----------------------------------------------------------------------------
ResourceUsage& ResourceUsage::operator=(const ResourceUsage& rhs)
{
  if (this != &rhs)
  {
    cpu = rhs.cpu;
    iowait = rhs.iowait;
    vramUsed = rhs.vramUsed;
    vramUsedPercent = rhs.vramUsedPercent;
    rramUsed = rhs.rramUsed;
    rramUsedPercent = rhs.rramUsedPercent;
    diskUsed = rhs.diskUsed;
    diskUsedPercent = rhs.diskUsedPercent;
    processes = rhs.processes;
    processesPercent = rhs.processesPercent;
    threads = rhs.threads;
    threadsPercent = rhs.threadsPercent;
    loadAverage = rhs.loadAverage;
  }
  return *this;
}
//-----------------------------------------------------------------------------
ResourceUsage& ResourceUsage::operator=(ResourceUsage&& rhs)
{
  if (this != &rhs)
  {
    cpu = std::move(rhs.cpu);
    iowait = std::move(rhs.iowait);
    vramUsed = std::move(rhs.vramUsed);
    vramUsedPercent = std::move(rhs.vramUsedPercent);
    rramUsed = std::move(rhs.rramUsed);
    rramUsedPercent = std::move(rhs.rramUsedPercent);
    diskUsed = std::move(rhs.diskUsed);
    diskUsedPercent = std::move(rhs.diskUsedPercent);
    processes = std::move(rhs.processes);
    processesPercent = std::move(rhs.processesPercent);
    threads = std::move(rhs.threads);
    threadsPercent = std::move(rhs.threadsPercent);
    loadAverage = std::move(rhs.loadAverage);
  }
  return *this;
}
//-----------------------------------------------------------------------------
void ResourceUsage::clear(void)
{
  cpu = 0.0;
  iowait = 0.0;
  vramUsed = 0;
  vramUsedPercent = 0.0;
  rramUsed = 0;
  rramUsedPercent = 0.0;
  diskUsed = 0;
  diskUsedPercent = 0.0;
  processes = 0;
  processesPercent = 0.0;
  threads = 0;
  threadsPercent = 0.0;
  loadAverage = 0.0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ResourceUsageConverter::ResourceUsageConverter(void)
: resourceUsage()
{
}
//-----------------------------------------------------------------------------
ResourceUsageConverter::ResourceUsageConverter(const ResourceUsage& rhs)
: resourceUsage(rhs)
{
}
//-----------------------------------------------------------------------------
ResourceUsageConverter::ResourceUsageConverter(const std::string& rhs)
: resourceUsage()
{
  fromString(rhs);
}
//-----------------------------------------------------------------------------
std::string ResourceUsageConverter::toString(const char delimiter)
{
  std::ostringstream ostr;
  ostr << resourceUsage.cpu << delimiter
      << resourceUsage.iowait << delimiter
      << resourceUsage.vramUsedPercent << delimiter
      << resourceUsage.rramUsedPercent << delimiter
      << resourceUsage.diskUsedPercent << delimiter
      << resourceUsage.processesPercent << delimiter
      << resourceUsage.threadsPercent << delimiter
      << resourceUsage.loadAverage;
  return ostr.str();
}
//-----------------------------------------------------------------------------
void ResourceUsageConverter::fromObject(const ResourceUsage& rhs)
{
  resourceUsage = rhs;
}
//-----------------------------------------------------------------------------
void ResourceUsageConverter::fromString(const std::string& rhs, const char delimiter)
{
  resourceUsage.clear();
  std::string str(rhs);
  std::replace(str.begin(), str.end(), delimiter, ' ');
  std::stringstream istr(str);
  std::istream_iterator<std::string> iit(istr);
  std::istream_iterator<std::string> eos;

  if (iit != eos)
    std::istringstream(*iit) >> resourceUsage.cpu;

  if (++iit != eos)
    std::istringstream(*iit) >> resourceUsage.iowait;

  if (++iit != eos)
    std::istringstream(*iit) >> resourceUsage.vramUsedPercent;

  if (++iit != eos)
    std::istringstream(*iit) >> resourceUsage.rramUsedPercent;

  if (++iit != eos)
    std::istringstream(*iit) >> resourceUsage.diskUsedPercent;

  if (++iit != eos)
    std::istringstream(*iit) >> resourceUsage.processesPercent;

  if (++iit != eos)
    std::istringstream(*iit) >> resourceUsage.threadsPercent;

  if (++iit != eos)
    std::istringstream(*iit) >> resourceUsage.loadAverage;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ResourceUsageSerializator::ResourceUsageSerializator(ResourceUsage& resourceUsage_)
: inherited(), resourceUsage(resourceUsage_)
{
}
//-----------------------------------------------------------------------------
ResourceUsageSerializator::ResourceUsageSerializator(ResourceUsage& resourceUsage_, const std::string& json)
: inherited(), resourceUsage(resourceUsage_)
{
  if (!json.empty())
    unserialize(json);
}
//-----------------------------------------------------------------------------
bool ResourceUsageSerializator::serialize(std::string& json)
{
  resetError();
  try
  {
    Poco::JSON::Object::Ptr pObj = new Poco::JSON::Object();
    if (pObj.isNull())
      throw Poco::Exception(message_const::objectInstanceWasNotCreated);

    HCE::TrimFormatter <double> trim;
    pObj->set(HCE::drce::drce_json_message_const::CPU, trim(resourceUsage.cpu));
    pObj->set(HCE::drce::drce_json_message_const::IOWAIT, trim(resourceUsage.iowait));
    pObj->set(HCE::drce::drce_json_message_const::VRAM, trim(resourceUsage.vramUsedPercent));
    pObj->set(HCE::drce::drce_json_message_const::RRAM, trim(resourceUsage.rramUsedPercent));
    pObj->set(HCE::drce::drce_json_message_const::DISK, trim(resourceUsage.diskUsedPercent));
    pObj->set(HCE::drce::drce_json_message_const::PROCESSES, trim(resourceUsage.processesPercent));
    pObj->set(HCE::drce::drce_json_message_const::THREADS, trim(resourceUsage.threadsPercent));
    pObj->set(HCE::drce::drce_json_message_const::LOADAVG, trim(resourceUsage.loadAverage));

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(pObj, ostr);
    json = ostr.str();
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorMsg = e.message();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool ResourceUsageSerializator::unserialize(const std::string& json)
{
  clear();
  resetError();
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr pObj = res.extract<Poco::JSON::Object::Ptr>();
    if (!pObj.isNull())
    {
      Poco::Dynamic::Var tmp = pObj->get(HCE::drce::drce_json_message_const::CPU);
      resourceUsage.cpu = convertVarToNumeric<double>(tmp, 0.0);

      tmp = pObj->get(HCE::drce::drce_json_message_const::IOWAIT);
      resourceUsage.iowait = convertVarToNumeric<double>(tmp, 0.0);

      tmp = pObj->get(HCE::drce::drce_json_message_const::VRAM);
      resourceUsage.vramUsedPercent = convertVarToNumeric<double>(tmp, 0.0);

      tmp = pObj->get(HCE::drce::drce_json_message_const::RRAM);
      resourceUsage.rramUsedPercent = convertVarToNumeric<double>(tmp, 0.0);

      tmp = pObj->get(HCE::drce::drce_json_message_const::DISK);
      resourceUsage.diskUsedPercent = convertVarToNumeric<double>(tmp, 0.0);

      tmp = pObj->get(HCE::drce::drce_json_message_const::PROCESSES);
      resourceUsage.processesPercent = convertVarToNumeric<double>(tmp, 0.0);

      tmp = pObj->get(HCE::drce::drce_json_message_const::THREADS);
      resourceUsage.threadsPercent = convertVarToNumeric<double>(tmp, 0.0);

      tmp = pObj->get(HCE::drce::drce_json_message_const::LOADAVG);
      resourceUsage.loadAverage = convertVarToNumeric<double>(tmp, 0.0);
    }
  }
  catch(Poco::JSON::JSONException& e)
  {
    _isError = true;
    errorMsg = e.message();
    errorCode = ERROR_UNSERIALIZE;
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorMsg = e.message();
    errorCode = e.code();
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorMsg = e.what();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
void ResourceUsageSerializator::clear(void)
{
  resourceUsage.clear();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
}// end namespace drce 
} // end namespace HCE