ProcessParser.h

#pragma once
#include <algorithm>
#include <iostream>
#include <math.h>
#include <thread>
#include <chrono>
#include <iterator>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <cerrno>
#include <cstring>
#include <dirent.h>
#include <time.h>
#include <unistd.h>
#include "constants.h"
#include "util.h"

class ProcessParser {
public:
    static std::string getCmd(const std::string& pid);
    static std::vector<std::string> getPidList();
    static std::string getVmSize(const std::string& pid);
    static std::string getCpuPercent(const std::string& pid);
    static double getSysUpTime();
    static std::string getProcUpTime(const std::string& pid);
    static std::string getProcUser(const std::string& pid);
    static std::vector<std::string> getSysCpuPercent(std::string coreNumber = "");
    static float getSysRamPercent();
    static std::string getSysKernelVersion();
    static int getTotalThreads();
    static int getNumberOfCores(); 
    static int getTotalNumberOfProcesses();
    static int getNumberOfRunningProcesses();
    static std::string getOsName();
    static float getSysActiveCpuTime(std::vector<std::string> values);
    static float getSysIdleCpuTime(std::vector<std::string> values);
    static std::string printCpuStats(std::vector<std::string> values1, std::vector<std::string> values2);
};

inline std::string ProcessParser::getCmd(const std::string& pid){
    std::ifstream input = Util::getStream((Path::basePath() + pid + Path::cmdPath()));
    std::string cmdLine;
    std::getline(input, cmdLine);
    return cmdLine;
}

inline std::vector<std::string> ProcessParser::getPidList(){
    std::vector<std::string> pidList;
    DIR* dir = opendir(Path::basePath().c_str());
    struct dirent* dp;
    while((dp = readdir(dir)) != nullptr){
        std::string line = dp->d_name;
        if(std::all_of(line.begin(),line.end(), ::isdigit))
        pidList.push_back(line);
    }
    closedir(dir);
    return pidList;
}

inline std::string ProcessParser::getVmSize(const std::string& pid){
    std::ifstream input = Util::getStream((Path::basePath() + pid + Path::statusPath()));
    std::string vmSize;
    while (std::getline(input, vmSize))
    {
        if(vmSize.rfind("VmSize:",0) == 0) {
            std::istringstream iss(vmSize);
            std::string key, value, unit;
            iss >> key >> value >> unit;
            return std::to_string(stof(value)/float(1024))+" "+"MB";
        }
    }
    return "0 MB";
}

inline std::string ProcessParser::getCpuPercent(const std::string& pid){
    std::ifstream stat = Util::getStream(Path::basePath() + pid + "/" + Path::statPath());
    std::string line;
    std::string utime;
    std::string stime;
    std::string starttime;
    std::getline(stat, line);
    std::istringstream iss(line);
    std::string token;
    int index =1;
    while(iss >> token){
        switch (index)
        {
        case 14:
            utime = token;
            break;
        case 15:
            stime = token;
            break;
        case 22:
            starttime = token;
            break;
        }
        ++index;
    }

    double uptime = ProcessParser::getSysUpTime();
    double hertz = sysconf(_SC_CLK_TCK);
    if((uptime - (stof(starttime)/hertz)) <= 0.0000001)return "0.0";
    return std::to_string(100 * ((stof(utime)+stof(stime)) / hertz) / (uptime - (stof(starttime)/hertz)));
}

inline double ProcessParser::getSysUpTime(){
    std::ifstream uptimeFile = Util::getStream((Path::basePath()+Path::upTimePath()));
    std::string line;
    std::getline(uptimeFile, line);
    std::istringstream iss(line);
    iss >> line;
    return stod(line);
}

inline std::string ProcessParser::getProcUpTime(const std::string& pid){
    std::ifstream stat = Util::getStream((Path::basePath() + pid + "/" + Path::statPath()));
    std::string line;
    std::getline(stat,line);
    std::istringstream iss(line);
    std::string token;
    int index =1;
    std::string starttime;
    while(iss >>token){
        if(index == 22)starttime = token;
        index++;
    }
    double uptime = ProcessParser::getSysUpTime();
    double hertz = sysconf(_SC_CLK_TCK);
    return std::to_string(uptime - (stod(starttime) / hertz));
}

inline std::string ProcessParser::getProcUser(const std::string& pid){
    std::ifstream stream = Util::getStream((Path::basePath() + pid + Path::statusPath()));
    std::string line;
    std::string user;
    while(std::getline(stream, line)){
        if(line.rfind("Uid:",0) == 0){
            std::istringstream iss(line);
            std::string key;
            iss >> key >>user;
            break;
        }
    }

    stream = Util::getStream("/etc/passwd");
    while(std::getline(stream, line)){
        if(line.find(("x:"+user)) != std::string::npos){
            user = line.substr(0,line.find(":"));
            return user;
        }
    }
    return std::string();
}

inline std::vector<std::string> ProcessParser::getSysCpuPercent(std::string coreNumber){
    std::ifstream stat = Util::getStream((Path::basePath()+Path::statPath()));
    std::string line,name = "cpu"+coreNumber ;
    while(std::getline(stat,line)){
        if(line.rfind(name,0) == 0){
            std::istringstream iss(line);
            std::istream_iterator<std::string> beg(iss),end;
            std::vector<std::string> values(beg,end);
            return  values;
        }
    }
    return (std::vector<std::string>());
}

inline float ProcessParser::getSysRamPercent(){
    std::ifstream meminfo = Util::getStream((Path::basePath()+Path::mamInfoPath()));
    std::string line,key;
    float memFree,memAvailable,buffers;
    while(std::getline(meminfo,line)){
        std::istringstream iss(line);
        if(line.rfind("MemFree:",0) == 0){
            iss >> key >> memFree;
        }
        else if(line.rfind("MemAvailable:",0) == 0){
            iss >> key >> memAvailable;
        }
        else if(line.rfind("Buffers:",0) == 0){
            iss >> key >> buffers;
        }
    }
    return float(100.0*(1-(memFree/(memAvailable-buffers))));
}

inline std::string ProcessParser::getSysKernelVersion(){
    std::ifstream input = Util::getStream((Path::basePath()+Path::versionPath()));
    std::string line,token1,token2,token3;
    std::getline(input, line);
    std::istringstream iss(line);
    if(iss >> token1 >> token2 >> token3)
    return token3;
    else 
    return std::string();
}

inline int ProcessParser::getTotalThreads(){
    int totalThreads =0;
    std::vector<std::string> pidList = ProcessParser::getPidList();
    for(const std::string& pid : pidList){
        try {
            std::ifstream stream = Util::getStream((Path::basePath()+pid+Path::statusPath()));
            std::string line,key,value;
            while(getline(stream,line)){
                if(line.rfind("Threads:",0)==0){
                    std::istringstream iss(line);
                    iss >> key >> value;
                    totalThreads += std::stoi(value);
                    break;
                }
            }
        } catch (...) {
            continue;
        }
    }
    return totalThreads;
}

inline int ProcessParser::getNumberOfCores() {
    return sysconf(_SC_NPROCESSORS_ONLN);
}


inline int ProcessParser::getTotalNumberOfProcesses()
{
    std::ifstream stream = Util::getStream((Path::basePath() + Path::statPath()));
    std::string line,key ,value;
    while (std::getline(stream, line)) {
        if (line.rfind("processes",0) == 0) {
            std::istringstream iss(line);
            iss >> key >> value;
            break;
        }
    }
    return std::stoi(value);
}

inline int ProcessParser::getNumberOfRunningProcesses()
{
    std::ifstream stream = Util::getStream((Path::basePath() + Path::statPath()));
    std::string line,key ,value;
    while (std::getline(stream, line)) {
        if (line.rfind("procs_running",0) == 0) {
            std::istringstream iss(line);
            iss >> key >> value;
            break;
        }
    }
    return std::stoi(value);
}
inline std::string ProcessParser::getOsName(){
    std::ifstream stream = Util::getStream(("/etc/os-release"));
    std::string line;
    while (std::getline(stream, line)) {
        if (line.rfind("PRETTY_NAME=",0) == 0) {
            std::string result = line.substr(line.find("=")+1);
            
            if (result.front() == '"' && result.back() == '"') {
                result = result.substr(1, result.length()-2);
            }
            return result;
        }
    }
    return std::string();
}

inline float ProcessParser::getSysActiveCpuTime(std::vector<std::string> values){
    return (stof(values[CPUStates::S_USER]) +
            stof(values[CPUStates::S_NICE]) +
            stof(values[CPUStates::S_SYSTEM]) +
            stof(values[CPUStates::S_IRQ]) +
            stof(values[CPUStates::S_SOFTIRQ]) +
            stof(values[CPUStates::S_STEAL]) +
            stof(values[CPUStates::S_GUEST]) +
            stof(values[CPUStates::S_GUEST_NICE]));
}

inline float ProcessParser::getSysIdleCpuTime(std::vector<std::string> values){
    return (stof(values[CPUStates::S_IDLE]) + 
            stof(values[CPUStates::S_IOWAIT]));
}

inline std::string ProcessParser::printCpuStats(std::vector<std::string> values1, std::vector<std::string> values2){
    float activeTime = getSysActiveCpuTime(values2) - getSysActiveCpuTime(values1);
    float idleTime = getSysIdleCpuTime(values2) - getSysIdleCpuTime(values1);
    float totalTime = activeTime + idleTime;
    
    
    if(totalTime == 0) {
        return "0.0";
    }
    
    float result = 100.0 * (activeTime / totalTime);
    
    
    char buffer[32];
    snprintf(buffer, sizeof(buffer), "%.2f", result);
    return std::string(buffer);
}