!3 fiter the vtm processes

Module/mod_guiconsole/guiconsole_define.cpp

@@ -2,6 +2,7 @@
 #include <winpr/sysinfo.h>
 #include <EventCode.h>
 #include <unordered_map>
+#include <cmath>
 
 std::string GenerateTimeStr()
 {
@@ -247,110 +248,27 @@ std::pair<long, std::string> PollProcessList(long UpdateTime, system_monitor_sta
 }
 
 #else
-#include <fstream>
-#include <unistd.h>
-#include <dirent.h>
-#include <cstring>
-#include <unordered_map>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <map>
-
-
-double get_cpu_usage(int pid) {
-	static std::unordered_map<int, double> prev_cpu_times;
-	std::ifstream stat_file("/proc/" + std::to_string(pid) + "/stat");
-	std::string line;
-	std::getline(stat_file, line);
-	std::istringstream iss(line);
-	std::string field;
-	unsigned long long utime, stime;
-	for (int i = 1; i <= 13; ++i) {
-		iss >> field;
-		if (i == 13) {
-			utime = std::stoull(field);
-		}
-		else if (i == 14) {
-			stime = std::stoull(field);
-		}
-	}
-	stat_file.close();
 
-	unsigned long long total_time = utime + stime;
-	double cpu_usage = 0.0;
-	if (prev_cpu_times.find(pid) != prev_cpu_times.end()) {
-		unsigned long long prev_total_time = prev_cpu_times[pid];
-		cpu_usage = (total_time - prev_total_time) / sysconf(_SC_CLK_TCK) * 100.0;
-	}
-	prev_cpu_times[pid] = total_time;
-	return cpu_usage;
-}
-
-long get_memory_usage(int pid) {
-	std::ifstream status_file("/proc/" + std::to_string(pid) + "/status");
-	std::string line;
-	while (std::getline(status_file, line)) {
-		if (line.find("VmRSS") != std::string::npos) {
-			std::istringstream iss(line);
-			std::string field;
-			long memory_usage;
-			iss >> field >> memory_usage;
-			status_file.close();
-			return memory_usage * 1024; // Convert from KB to bytes
-		}
-	}
-	status_file.close();
-	return 0;
-}
-
-int get_num_handles(int pid) {
-	std::string fd_dir = "/proc/" + std::to_string(pid) + "/fd";
-	DIR* dir = opendir(fd_dir.c_str());
-	if (dir == nullptr) {
-		return 0;
-	}
-	int count = 0;
-	while (readdir(dir) != nullptr) {
-		++count;
-	}
-	closedir(dir);
-	return count;
-}
-
-void get_process_info(std::vector<processStatus>& processes) {
-	DIR* proc_dir = opendir("/proc");
-	if (proc_dir == nullptr) {
-		return;
-	}
-
-	struct dirent* entry;
-	while ((entry = readdir(proc_dir)) != nullptr) {
-		if (entry->d_type == DT_DIR && std::isdigit(entry->d_name[0])) {
-			int pid = std::stoi(entry->d_name);
-			std::string comm_file = "/proc/" + std::to_string(pid) + "/comm";
-			std::ifstream ifs(comm_file.c_str());
-			if (ifs.is_open()) {
-				std::string name;
-				std::getline(ifs, name);
-				ifs.close();
-
-				processStatus info;
-				info.processName = name;
-				info.ID = pid;
-				info.PercentProcessorTime = get_cpu_usage(pid);
-				info.UsedMemory = get_memory_usage(pid);
-				info.HandleCount = get_num_handles(pid);
-				processes.push_back(info);
-			}
-		}
-	}
-	closedir(proc_dir);
-}
+#include "linux_system_monitor/system.h"
 
 
 std::pair<long, std::string> PollProcessList(long UpdateTime, system_monitor_status& curStatus)
 {
-	get_process_info(curStatus.processList);
+	System system;
+	auto processArr = system.Processes();
+	curStatus.processList.clear();
+	for (auto it : processArr)
+	{
+		processStatus cur;
+		cur.ID = it.Pid();
+		cur.processName = it.name();
+		char buffer[20];
+		std::sprintf(buffer, "%.2f", it.CpuUtilization());
+		cur.PercentProcessorTime = std::atof(buffer);
+		cur.UsedMemory = std::stoi(it.Ram());
+		cur.HandleCount = it.fdHandles();
+		curStatus.processList.push_back(cur);
+	}
 
 
 	return std::make_pair(0, "");

Module/mod_guiconsole/guiconsole_define.h

@@ -87,14 +87,14 @@ struct TerminalBaseInfo
 // ½« process ¸ÄÃûΪ processStatus
 struct processStatus {
     std::string processName;
-    DWORD ID;
+    int ID;
     double PercentProcessorTime;
     unsigned long UsedMemory;
     double PercentMemory;
-    DWORD HandleCount;
+    int HandleCount;
 
 
-	TCHAR UserName[MAX_PATH];
+	char UserName[MAX_PATH];
 	//ULONGLONG UpTime;
     //DWORD BasePriority;
     //DWORD ParentPID;

Module/mod_guiconsole/linux_system_monitor/linux_parser.cpp

@@ -161,6 +161,34 @@ string LinuxParser::Command(int pid) {
   return cmd;
 }
 
+std::string LinuxParser::name(int pid)
+{
+    string name = "";
+
+    std::string comm_file = "/proc/" + std::to_string(pid) + "/comm";
+    std::ifstream ifs(comm_file.c_str());
+    if (ifs.is_open()) {
+        std::getline(ifs, name);
+        ifs.close();
+    }
+    return name;
+}
+
+int LinuxParser::fdHandles(int pid)
+{
+    std::string fd_dir = "/proc/" + std::to_string(pid) + "/fd";
+    DIR* dir = opendir(fd_dir.c_str());
+    if (dir == nullptr) {
+        return 0;
+    }
+    int count = 0;
+    while (readdir(dir) != nullptr) {
+        ++count;
+    }
+    closedir(dir);
+    return count;
+}
+
 // TODO: Read and return the memory used by a process
 string LinuxParser::Ram(int pid) { 
   
@@ -266,6 +294,29 @@ long int LinuxParser::UpTime(int pid) {
   
 }
 
+float LinuxParser::ProcessMemoryUtilization(int pid)
+{
+    string line;
+    string key;
+    string value = std::to_string(0);
+    string path = kProcDirectory + "/" + std::to_string(pid) + "/status";
+
+    std::ifstream filestream(path);
+    if (filestream.is_open()) {
+        while (std::getline(filestream, line)) {
+            std::replace(line.begin(), line.end(), ':', ' ');
+            std::istringstream linestream(line);
+            while (linestream >> key >> value) {
+                if (key == "VmRSS") {
+                    //std::cout<< " match!" << std::to_string(pid) << " \n";
+                    return std::stoi(value);
+                }
+            }
+        }
+    }
+    return 0;
+}
+
 
 float LinuxParser::CpuUtilization(int pid){
 

Module/mod_guiconsole/linux_system_monitor/linux_parser.h

@@ -53,6 +53,9 @@ std::string Uid(int pid);
 std::string User(int pid);
 long int UpTime(int pid);
 float CpuUtilization(int pid);
+float ProcessMemoryUtilization(int pid);
+std::string name(int pid);
+int fdHandles(int pid);
 };  // namespace LinuxParser
 
 #endif

Module/mod_guiconsole/linux_system_monitor/process.cpp

@@ -17,6 +17,8 @@ int Process::Pid() { return pid; }
 // TODO: Return this process's CPU utilization
 float Process::CpuUtilization() const { return LinuxParser::CpuUtilization(pid);}
 
+float Process::MemUtilization() const { return LinuxParser::ProcessMemoryUtilization(pid); }
+
 // TODO: Return the command that generated this process
 string Process::Command() { return LinuxParser::Command(pid); }
 
@@ -26,9 +28,13 @@ string Process::Ram() { return LinuxParser::Ram(pid); }
 // TODO: Return the user (name) that generated this process
 string Process::User() { return LinuxParser::User(pid); }
 
+string Process::name() { return LinuxParser::name(pid); }
+
 // TODO: Return the age of this process (in seconds)
 long int Process::UpTime() { return LinuxParser::UpTime(pid); }
 
+int Process::fdHandles() { return LinuxParser::fdHandles(pid); }
+
 // TODO: Overload the "less than" comparison operator for Process objects
 // REMOVE: [[maybe_unused]] once you define the function
 bool Process::operator<(Process const &b)  { 

Module/mod_guiconsole/linux_system_monitor/process.h

@@ -14,10 +14,13 @@ class Process {
  public:
   int Pid();                               // TODO: See src/process.cpp
   std::string User();                      // TODO: See src/process.cpp
+  std::string name();                      // TODO: See src/process.cpp
   std::string Command();                   // TODO: See src/process.cpp
   float CpuUtilization() const;                  // TODO: See src/process.cpp
+  float MemUtilization() const;                  // TODO: See src/process.cpp
   std::string Ram();                       // TODO: See src/process.cpp
   long int UpTime();                       // TODO: See src/process.cpp
+  int fdHandles();                       // TODO: See src/process.cpp
   bool operator<(Process const &b)     ;  // TODO: See src/process.cpp
   Process(int);
 

Module/mod_guiconsole/mod_guiconsole.cpp

@@ -315,19 +315,39 @@ std::pair<DWORD, std::string> CGUIConsoleEntity::openPerformanceSender(SpReqAnsC
 			system_monitor_status curStatus;
 			auto pullret = PollProcessList(m_performanceSenderFrequence, curStatus);
 
+			const std::vector<std::string> vtmProcess = std::initializer_list<std::string>{"spshell", "sphost", "guardian", "cefclient", "uosbrowser", "browser"};
+
+			std::vector<processStatus> vtmProcessArr;
+			for (auto it : curStatus.processList)
+			{
+				for (auto it2 : vtmProcess)
+				{
+					std::string processName = it.processName;
+					std::for_each(processName.begin(), processName.end(), [](char& c) {
+						c = std::tolower(c);
+						});
+					if (processName.find(it2) != -1)
+					{
+						vtmProcessArr.push_back(it);
+						break;
+					}
+				}
+			}
+
+
 			PerformanceList dst;
-			dst.NameArr.Init(curStatus.processList.size());
-			dst.pidArr.Init(curStatus.processList.size());
-			dst.cpuArr.Init(curStatus.processList.size());
-			dst.memoryArr.Init(curStatus.processList.size());
-			dst.handleNumArr.Init(curStatus.processList.size());
-			for (int i = 0; i < curStatus.processList.size(); i++)
+			dst.NameArr.Init(vtmProcessArr.size());
+			dst.pidArr.Init(vtmProcessArr.size());
+			dst.cpuArr.Init(vtmProcessArr.size());
+			dst.memoryArr.Init(vtmProcessArr.size());
+			dst.handleNumArr.Init(vtmProcessArr.size());
+			for (int i = 0; i < vtmProcessArr.size(); i++)
 			{
-				dst.NameArr[i] = curStatus.processList[i].processName.c_str();
-				dst.pidArr[i] = curStatus.processList[i].ID;
-				dst.cpuArr[i] = curStatus.processList[i].PercentProcessorTime;
-				dst.memoryArr[i] = curStatus.processList[i].PercentMemory;
-				dst.handleNumArr[i] = curStatus.processList[i].HandleCount;
+				dst.NameArr[i] = vtmProcessArr[i].processName.c_str();
+				dst.pidArr[i] = vtmProcessArr[i].ID;
+				dst.cpuArr[i] = vtmProcessArr[i].PercentProcessorTime;
+				dst.memoryArr[i] = (double)vtmProcessArr[i].UsedMemory;
+				dst.handleNumArr[i] = vtmProcessArr[i].HandleCount;
 			}
 			SpSendBroadcast(GetFunction(), eMsg_PerformanceList, eMsgSig_PerformanceList, dst);