Adding information about processes

Author: textanalyticsman

include/process.h

@@ -8,16 +8,29 @@ It contains relevant attributes as shown below
 */
 class Process {
  public:
+  Process(int pid, std::string puser = "", std::string pcommand = "", float pcpu = 0, std::string pram = "", long puptime = 0);
   int Pid();                               // TODO: See src/process.cpp
   std::string User();                      // TODO: See src/process.cpp
   std::string Command();                   // TODO: See src/process.cpp
   float CpuUtilization();                  // TODO: See src/process.cpp
   std::string Ram();                       // TODO: See src/process.cpp
   long int UpTime();                       // TODO: See src/process.cpp
   bool operator<(Process const& a) const;  // TODO: See src/process.cpp
-
+  // To set values
+  void SetPid(int pid);
+  void SetPuser(std::string puser);
+  void SetPcommand(std::string pcommand);
+  void SetPcpu(float pcpu);
+  void SetPram(std::string pram);
+  void SetPuptime(long puptime);
   // TODO: Declare any necessary private members
  private:
+  int process_id;
+  std::string process_user;
+  std::string process_command;
+  float process_cpu_utilization;
+  std::string process_ram;
+  long process_up_time;
 };
 
 #endif

src/linux_parser.cpp

@@ -182,13 +182,54 @@ string LinuxParser::Command(int pid[[maybe_unused]]) { return string(); }
 // REMOVE: [[maybe_unused]] once you define the function
 string LinuxParser::Ram(int pid[[maybe_unused]]) { return string(); }
 
-// TODO: Read and return the user ID associated with a process
-// REMOVE: [[maybe_unused]] once you define the function
-string LinuxParser::Uid(int pid[[maybe_unused]]) { return string(); }
+// Read and return the user ID associated with a process
+string LinuxParser::Uid(int pid) 
+{
+  std::string line;
+  std::string pattern{ R"(Uid:\s+(\d+))" };
+
+  std::ifstream filestream(kProcDirectory + std::to_string(pid) + kStatusFilename);
+  std::string user_id;
+
+  if (filestream.is_open()) 
+  {
+    while (std::getline(filestream, line)) 
+    {
+      user_id = RegularExpression(pattern, line, 1);
+
+      if(user_id != "")
+        break;
+    }
+  }
+
+  return user_id;
+}
 
 // TODO: Read and return the user associated with a process
 // REMOVE: [[maybe_unused]] once you define the function
-string LinuxParser::User(int pid[[maybe_unused]]) { return string(); }
+string LinuxParser::User(int pid) 
+{
+  std::string line;
+
+  std::string uid { Uid(pid) };
+  std::string pattern{ "(\\w+[-]*\\w+):x:" + uid };
+
+  std::ifstream filestream(kPasswordPath);
+  std::string user_name;
+
+  if (filestream.is_open()) 
+  {
+    while (std::getline(filestream, line)) 
+    {
+      user_name = RegularExpression(pattern, line, 1);
+
+      if(user_name != "")
+        break;
+    }
+  }
+
+  return user_name;
+}
 
 // TODO: Read and return the uptime of a process
 // REMOVE: [[maybe_unused]] once you define the function

src/process.cpp

@@ -10,23 +10,42 @@ using std::string;
 using std::to_string;
 using std::vector;
 
-// TODO: Return this process's ID
-int Process::Pid() { return 0; }
-
-// TODO: Return this process's CPU utilization
-float Process::CpuUtilization() { return 0; }
-
-// TODO: Return the command that generated this process
-string Process::Command() { return string(); }
-
-// TODO: Return this process's memory utilization
-string Process::Ram() { return string(); }
-
-// TODO: Return the user (name) that generated this process
-string Process::User() { return string(); }
-
-// TODO: Return the age of this process (in seconds)
-long int Process::UpTime() { return 0; }
+Process::Process(int pid, std::string puser, std::string pcommand, float pcpu, std::string pram, long puptime)
+        :process_id{ pid }, process_user{ puser }, process_command{ pcommand }, process_cpu_utilization{ pcpu }, process_ram{ pram }, process_up_time{ puptime }
+{
+
+}
+
+// Set process ID
+void Process::SetPid(int pid){ Process::process_id = pid; }
+// Set process user
+void Process::SetPuser(std::string puser){ Process::process_user = puser; }
+// Set process command
+void Process::SetPcommand(std::string pcommand){ Process::process_command = pcommand; }
+// Set process CPU consumption
+void Process::SetPcpu(float pcpu){ Process::process_cpu_utilization = pcpu; }
+// Set process RAM consumption
+void Process::SetPram(std::string pram){ Process::process_ram = pram; }
+// Set process uptime
+void Process::SetPuptime(long puptime){ Process::process_up_time = puptime; }
+
+// Return this process's ID
+int Process::Pid() { return Process::process_id; }
+
+// Return this process's CPU utilization
+float Process::CpuUtilization() { return Process::process_cpu_utilization; }
+
+// Return the command that generated this process
+string Process::Command() { return Process::process_command; }
+
+// Return this process's memory utilization
+string Process::Ram() { return Process::process_ram; }
+
+// Return the user (name) that generated this process
+string Process::User() { return Process::process_user; }
+
+// Return the age of this process (in seconds)
+long int Process::UpTime() { return Process::process_up_time; }
 
 // TODO: Overload the "less than" comparison operator for Process objects
 // REMOVE: [[maybe_unused]] once you define the function

src/processor.cpp

@@ -1,21 +1,14 @@
 #include "processor.h"
 #include "linux_parser.h"
-#include <thread>
-#include <chrono>
-#include <iostream>
 
 // Return the aggregate CPU utilization
 float Processor::Utilization() 
 {
   // I have used the algorihm proposed at https://stackoverflow.com/questions/23367857/accurate-calculation-of-cpu-usage-given-in-percentage-in-linux
 
-  // First reading to get CPU numbers
+  // Reading to get CPU data
   Processor::cpu_data.push_back(LinuxParser::CpuUtilization());
-  // Sleep during some time before executing second reading. Idea taken from https://stackoverflow.com/questions/52268378/c-usleep-returns-immediately-on-linux
-  std::this_thread::sleep_for(std::chrono::milliseconds(Processor::delay_reading));
-  // Second reading
-  Processor::cpu_data.push_back(LinuxParser::CpuUtilization());
-  
+    
   float first_idle{ 0.0 };
   float first_non_idle{ 0.0 };
   float first_total{ 0.0 };
@@ -27,29 +20,51 @@ float Processor::Utilization()
   unsigned const int index_idle{3};
   unsigned const int index_wait{4};
 
-  for(long unsigned int i=0; i<cpu_data[0].size(); ++i)
+  float consumption {0.0};
+
+  if(cpu_data.size() == 1)
   {
-    if(i==index_idle || i==index_wait)
-    {
-        first_idle += std::stof(cpu_data[0][i]);
-        second_idle += std::stof(cpu_data[1][i]);
-    }
-    else
+    for(long unsigned int i=0; i<cpu_data[0].size(); ++i)
     {
-        first_non_idle += std::stof(cpu_data[0][i]);
-        second_non_idle += std::stof(cpu_data[1][i]);
-    }
-  }        
+        if(i==index_idle || i==index_wait)
+            first_idle += std::stof(cpu_data[0][i]);
+        else
+            first_non_idle += std::stof(cpu_data[0][i]);
+    } 
+       
+    first_total = first_idle + first_non_idle;
+    second_total = second_idle + second_non_idle;
 
-  cpu_data.clear();
+    float total_difference {second_total - first_total};
+    float idle_difference {second_idle - first_idle};
+
+    consumption = (total_difference - idle_difference) / total_difference;     
+  }  
+  else if(cpu_data.size() == 2)
+  {
+    for(long unsigned int i=0; i<cpu_data[0].size(); ++i)
+    {
+        if(i==index_idle || i==index_wait)
+        {
+            first_idle += std::stof(cpu_data[0][i]);
+            second_idle += std::stof(cpu_data[1][i]);
+        }
+        else
+        {
+            first_non_idle += std::stof(cpu_data[0][i]);
+            second_non_idle += std::stof(cpu_data[1][i]);
+        }
+    }        
 
-  first_total = first_idle + first_non_idle;
-  second_total = second_idle + second_non_idle;
+    first_total = first_idle + first_non_idle;
+    second_total = second_idle + second_non_idle;
 
-  float total_difference {second_total - first_total};
-  float idle_difference {second_idle - first_idle};
+    float total_difference {second_total - first_total};
+    float idle_difference {second_idle - first_idle};
 
-  float consumption {(total_difference - idle_difference) / total_difference};
+    consumption = (total_difference - idle_difference) / total_difference;
 
+    cpu_data.erase(cpu_data.begin());
+  }
   return consumption; 
 }

src/system.cpp

@@ -18,7 +18,18 @@ using std::vector;
 Processor& System::Cpu() { return cpu_; }
 
 // TODO: Return a container composed of the system's processes
-vector<Process>& System::Processes() { return processes_; }
+vector<Process>& System::Processes() 
+{ 
+    vector<int> list_pids = LinuxParser::Pids();
+    
+    for(int pid : list_pids)
+    {
+        Process process(pid, LinuxParser::User(pid));
+        processes_.push_back(process);
+    }
+
+    return processes_;
+}
 
 // TODO: Return the system's kernel identifier (string)
 std::string System::Kernel() { return string(); }