linux_networkload.cpp

Go to the documentation of this file.

/**
 * @author: Daniel Fuchs
 * @contact: fuxeysolutions@gmail.com
 *
 * distributed under the MIT License (MIT).
 * Copyright (c) Daniel Fuchs
 *
 */
#include "linux_networkload.hpp"
 
#include <algorithm>
#include <cstring>
#include <exception>
#include <fstream>
#include <iostream>
#include <list>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
 
const std::list<std::string> identifiers{"RXbytes",
                                         "RXpackets",
                                         "RXerrs",
                                         "RXdrop",
                                         "RXfifo",
                                         "RXframe",
                                         "RXcompressed",
                                         "RXmulticast",
                                         "TXbytes",
                                         "TXpackets",
                                         "TXerrs",
                                         "TXdrop",
                                         "TXfifo",
                                         "TXcolls",
                                         "TXcarrier",
                                         "TXcompressed"};
 
std::string
networkLoad::mapEnumToString(networkLoad::networkParam param)
{
    auto it = identifiers.begin();
    std::advance(it, static_cast<uint32_t>(param));
    return it->data();
}
 
std::shared_ptr<networkLoad::networkParser> networkLoad::networkParser::inst = nullptr;
 
networkLoad::networkLoad(std::string ethernetDataFileName, std::string ethName) :
    ethernetDataFile(std::move(ethernetDataFileName)), ethDev(std::move(ethName))
{
    networkParser::getNetworkParser()->parse(ethernetDataFileName);
}
 
void
networkLoad::networkParser::parse(const std::string& netFile)
{
 
    if ((this->currentTime + std::chrono::milliseconds(10)) > std::chrono::system_clock::now())
    {
        return;
    }
    else
    {
        this->timeBefore = this->currentTime;
        this->currentTime = std::chrono::system_clock::now();
    }
 
    std::ifstream ethFile;
 
    try
    {
        ethFile.open(netFile);
    }
    catch (std::ifstream::failure& e)
    {
        throw std::runtime_error("Exception: " + netFile + std::string(e.what()));
    }
 
    this->timeBefore = std::chrono::system_clock::now();
    this->ethObjOld = this->ethObj;
 
    uint32_t lineCnt = 0;
    for (std::string line; std::getline(ethFile, line); lineCnt++)
    {
        if (lineCnt < 2)
        {
            continue;
        }
        std::stringstream strStream(line);
        std::string strPart;
        std::string ifName = "";
        std::unordered_map<std::string, uint64_t> ifValues;
        auto it = identifiers.begin();
        while (strStream >> strPart)
        {
            if (ifName.empty())
            {
                strPart.erase(std::remove_if(strPart.begin(),
                                             strPart.end(),
                                             [](auto c) { return !std::isalnum(c); }),
                              strPart.end());
                ifName = strPart;
            }
            else
            {
                if (it != identifiers.end())
                {
                    ifValues[it->data()] = std::stoull(strPart);
                }
                it++;
            }
        }
        this->ethObj[ifName] = ifValues;
    }
    if (this->ethObjOld.empty())
    {
        this->ethObjOld = this->ethObj;
    }
}
 
const std::unordered_map<std::string, uint64_t>&
networkLoad::networkParser::getEthObj(const std::string& ethDevice) const
{
    return this->ethObj.at(ethDevice);
}
 
const std::unordered_map<std::string, uint64_t>&
networkLoad::networkParser::getEthObjOld(const std::string& ethDevice) const
{
    return this->ethObjOld.at(ethDevice);
}
 
std::list<std::string>
networkLoad::networkParser::getNetworkDevices(std::string netFile)
{
    std::list<std::string> ifList;
    this->parse(netFile);
    for (const auto& elem : this->ethObj)
    {
        ifList.push_back(elem.first);
    }
    return ifList;
}
 
networkLoad::networkParser::networkParser()
{
    this->currentTime = std::chrono::system_clock::now() - std::chrono::milliseconds(100);
    this->timeBefore = std::chrono::system_clock::now();
}
 
std::shared_ptr<networkLoad::networkParser>
networkLoad::networkParser::getNetworkParser()
{
    if (networkLoad::networkParser::inst == nullptr)
    {
        networkLoad::networkParser::inst = std::make_unique<networkLoad::networkParser>();
    }
    return networkLoad::networkParser::inst;
}
 
const std::chrono::system_clock::time_point
networkLoad::networkParser::getTimeStamp() const
{
    return this->currentTime;
}
 
const std::chrono::system_clock::time_point
networkLoad::networkParser::getTimeBefore() const
{
    return this->timeBefore;
}
 
bool
networkLoad::isDeviceUp() const
{
    return this->isDeviceAvailable;
}
 
std::string
networkLoad::getDeviceName()
{
    return this->ethDev;
}
 
std::list<std::string>
networkLoad::scanNetworkDevices(const std::string& ethernetDataFile)
{
 
    auto parser = networkParser::getNetworkParser();
    return parser->getNetworkDevices(ethernetDataFile);
}
 
std::string
networkLoad::getBytesPerSeceondString(uint64_t bytesPerSecond)
{
    return getBytesString(bytesPerSecond) + "/s";
}
 
std::string
networkLoad::getBitsPerSeceondString(uint64_t bytesPerSecond)
{
    return getBitsString(bytesPerSecond) + "/s";
}
 
std::string
networkLoad::getBytesString(uint64_t totalBytes)
{
    uint64_t Bytes = totalBytes;
    uint64_t kByte = 0;
    uint64_t mByte = 0;
    uint64_t gByte = 0;
    if (Bytes > 1024)
    {
        kByte = Bytes / 1024;
        Bytes %= 1024;
    }
    if (kByte > 1024)
    {
        mByte = kByte / 1024;
        kByte %= 1024;
    }
    if (mByte > 1024)
    {
        gByte = mByte / 1024;
        mByte %= 1024;
    }
 
    if (gByte > 0)
    {
        std::string net;
        net += std::to_string(gByte);
        net += ".";
        net += std::to_string(mByte / 100);
        net += "gByte";
        return net;
    }
 
 
    if (mByte > 0)
    {
        std::string net;
        net += std::to_string(mByte);
        net += ".";
        net += std::to_string(kByte / 100);
        net += "mByte";
        return net;
    }
 
    if (kByte > 0)
    {
        std::string net;
        net += std::to_string(kByte);
        net += ".";
        net += std::to_string(Bytes / 100);
        net += "kByte";
        return net;
    }
 
    std::string net;
    net += std::to_string(Bytes);
    net += "Byte";
    return net;
}
 
std::string
networkLoad::getBitsString(uint64_t totalBytes)
{
    uint64_t Bytes = totalBytes * 8;
    uint64_t kByte = 0;
    uint64_t mByte = 0;
    uint64_t gByte = 0;
    if (Bytes > 1024)
    {
        kByte = Bytes / 1024;
        Bytes %= 1024;
    }
    if (kByte > 1024)
    {
        mByte = kByte / 1024;
        kByte %= 1024;
    }
    if (mByte > 1024)
    {
        gByte = mByte / 1024;
        mByte %= 1024;
    }
 
    if (gByte > 0)
    {
        std::string net;
        net += std::to_string(gByte);
        net += ".";
        net += std::to_string(mByte / 100);
        net += "gBit";
        return net;
    }
 
 
    if (mByte > 0)
    {
        std::string net;
        net += std::to_string(mByte);
        net += ".";
        net += std::to_string(kByte / 100);
        net += "mBit";
        return net;
    }
 
    if (kByte > 0)
    {
        std::string net;
        net += std::to_string(kByte);
        net += ".";
        net += std::to_string(Bytes / 100);
        net += "kBit";
        return net;
    }
 
 
    std::string net;
    net += std::to_string(Bytes);
    net += "Bit";
    return net;
}
 
uint64_t
networkLoad::getParamPerSecond(std::string designator)
{
    networkParser::getNetworkParser()->parse(this->ethernetDataFile);
    if (!std::count_if(identifiers.begin(),
                       identifiers.end(),
                       [designator](auto elem) { return elem == designator; }))
    {
        throw std::runtime_error("invalid designator: " + designator);
    }
    auto before = networkParser::getNetworkParser()->getTimeBefore();
    auto current = networkParser::getNetworkParser()->getTimeStamp();
 
    auto msec = std::chrono::duration_cast<std::chrono::milliseconds>(before - current);
 
    uint64_t Bytes = (networkParser::getNetworkParser()->getEthObj(this->ethDev).at(designator) -
                      networkParser::getNetworkParser()->getEthObjOld(this->ethDev).at(designator));
    if (static_cast<unsigned long>(msec.count()) <= 0)
    {
        Bytes /= 1;
    }
    else
    {
        Bytes /= static_cast<unsigned long>(msec.count());
    }
    return Bytes;
}
 
uint64_t
networkLoad::getParamSinceStartup(std::string designator)
{
    networkParser::getNetworkParser()->parse(this->ethernetDataFile);
    auto ifObj = networkParser::getNetworkParser()->getEthObj(this->ethDev);
    if (!std::count_if(identifiers.begin(),
                       identifiers.end(),
                       [designator](auto elem) { return elem == designator; }))
    {
        throw std::runtime_error("invalid designator: " + designator);
    }
    return ifObj[designator];
}