updated project

include/process.h

@@ -8,6 +8,7 @@ It contains relevant attributes as shown below
 */
 class Process {
  public:
+ Process(int pid);
  int Pid(); // TODO: See src/process.cpp
  std::string User(); // TODO: See src/process.cpp
  std::string Command(); // TODO: See src/process.cpp
@@ -18,6 +19,8 @@ class Process {
 
  // TODO: Declare any necessary private members
  private:
+ int pid_;
+ float cpu_utilization_;
 };
 
 #endif

src/format.cpp

@@ -8,4 +8,36 @@ using std::string;
 // INPUT: Long int measuring seconds
 // OUTPUT: HH:MM:SS
 // REMOVE: [[maybe_unused]] once you define the function
-string Format::ElapsedTime(long seconds[[maybe_unused]]) { return string(); }
+#include <string>
+
+#include "format.h"
+
+using std::string;
+using std::to_string;
+// TODO: Complete this helper function
+// INPUT: Long int measuring seconds
+// OUTPUT: HH:MM:SS
+// REMOVE: [[maybe_unused]] once you define the function
+string Format::ElapsedTime(long seconds) {
+ int h = 00;
+ int m = 00;
+ int s = 00;
+ string hour, min, sec;
+
+ h = seconds / (60 * 60);
+ m = seconds%(60 * 60) / 60;
+ s = seconds%(60 * 60) % 60; 
+
+ if (h < 10) {hour = "0" + to_string(h); }
+ else {hour = to_string(h); }
+
+ if (m < 10) {min = "0" + to_string(m); }
+ else {min = to_string(m); }
+
+ if (s < 10) {sec = "0" + to_string(s); }
+ else {sec = to_string(s); }
+
+ string time = hour + ": " + min + ": " + sec;
+
+ return time;
+}

src/linux_parser.cpp

@@ -6,6 +6,7 @@
 
 #include "linux_parser.h"
 
+using std::stoi;
 using std::stof;
 using std::string;
 using std::to_string;
@@ -42,9 +43,10 @@ string LinuxParser::Kernel() {
  if (stream.is_open()) {
  std::getline(stream, line);
  std::istringstream linestream(line);
- linestream >> os >> version >> kernel;
+
+ linestream >> os >> kernel >> version;
  }
- return kernel;
+ return version;
 }
 
 // BONUS: Update this to use std::filesystem
@@ -59,58 +61,230 @@ vector<int> LinuxParser::Pids() {
  string filename(file->d_name);
  if (std::all_of(filename.begin(), filename.end(), isdigit)) {
  int pid = stoi(filename);
- pids.push_back(pid);
+ pids.emplace_back(pid);
  }
  }
  }
  closedir(directory);
  return pids;
 }
-
 // TODO: Read and return the system memory utilization
-float LinuxParser::MemoryUtilization() { return 0.0; }
-
+ // ? Calculation : (Total memory - free memory) / Total Memory
+float LinuxParser::MemoryUtilization() { 
+ string line, label, value;
+ float total, free;
+
+ std::ifstream filestream(kProcDirectory + kMeminfoFilename);
+ if (filestream.is_open()) {
+ while (std::getline(filestream, line)) {
+ std::istringstream linestream(line);
+ while (linestream >> label >> value) {
+ if (label == "MemTotal:") {
+ total = stof(value);
+ }
+ if (label == "MemFree:") {
+ free = stof(value);
+ }
+ }
+ }
+ }
+ return (total - free) / total;
+}
+//use kernel example
 // TODO: Read and return the system uptime
-long LinuxParser::UpTime() { return 0; }
+long LinuxParser::UpTime() { 
+ string uptime, line;
+ std::ifstream stream(kProcDirectory + kUptimeFilename);
+ if (stream.is_open()) {
+ std::getline(stream, line);
+ std::istringstream linestream(line);
+ linestream >> uptime;
+ }
+ //stol--> converts string to long int
+ return std::stol(uptime);
+}
 
 // TODO: Read and return the number of jiffies for the system
-long LinuxParser::Jiffies() { return 0; }
+long LinuxParser::Jiffies() {
+ return LinuxParser::ActiveJiffies() + LinuxParser::IdleJiffies();
+}
+
+// Read and return the number of active jiffies for a PID
+long LinuxParser::ActiveJiffies(int pid) {
+ string line, value;
+ vector<string> values {};
+ long total;
+
+ std::ifstream filestream(kProcDirectory + to_string(pid) + kStatFilename);
+ if (filestream.is_open()) {
+ while (std::getline(filestream, line)) {
+ std::istringstream linestream(line);
+ while (linestream >> value) {
+ values.emplace_back(value);
+ }
+ }
+ }
+ total = stoi(values[13]) + stoi(values[14]) + stoi(values[15]) + stoi(values[16]); // total=utime+stime+cutime+cstime per stack overflow
+ return total / sysconf(_SC_CLK_TCK);
+}
+
+long LinuxParser::ActiveJiffies() {
+ // Read and return the number of active jiffies for the system
+ auto jiffies = CpuUtilization();
+
+ return stol(jiffies[CPUStates::kUser_]) + stol(jiffies[CPUStates::kNice_]) +
+ stol(jiffies[CPUStates::kSystem_]) + stol(jiffies[CPUStates::kIRQ_]) +
+ stol(jiffies[CPUStates::kSoftIRQ_]) +
+ stol(jiffies[CPUStates::kSteal_]);
+}
+
+long LinuxParser::IdleJiffies() {
+ // Read and return the number of idle jiffies for the system
+ auto jiffies = CpuUtilization();
+ return stol(jiffies[CPUStates::kIdle_]) + stol(jiffies[CPUStates::kIOwait_]);
+}
+
+
+vector<string> LinuxParser::CpuUtilization() {
+ // Read and return CPU utilization
+ string line, cpu, value;
+ vector<string> jiffies;
+ std::ifstream stream(kProcDirectory + kStatFilename);
+ if (stream.is_open()) {
+ std::getline(stream, line);
+ std::istringstream linestream(line);
+
+ linestream >> cpu;
+
+ while (linestream >> value) {
+ jiffies.emplace_back(value);
+ }
+ }
+ return jiffies;
+}
+
+int LinuxParser::TotalProcesses() {
+ // Read and return the total number of processes
+ int processes;
+ string key, line;
+ std::ifstream stream(kProcDirectory + kStatFilename);
+ if (stream.is_open()) {
+ while (std::getline(stream, line)) {
+ std::istringstream linestream(line);
+ linestream >> key;
+ if (key == "processes") {
+ linestream >> processes;
+ break;
+ }
+ }
+ }
+ return processes;
+}
 
-// TODO: Read and return the number of active jiffies for a PID
-// REMOVE: [[maybe_unused]] once you define the function
-long LinuxParser::ActiveJiffies(int pid[[maybe_unused]]) { return 0; }
+int LinuxParser::RunningProcesses() {
+ // Read and return the number of running processes
+ int processes;
+ string key, line;
+ std::ifstream stream(kProcDirectory + kStatFilename);
+ if (stream.is_open()) {
+ while (std::getline(stream, line)) {
+ std::istringstream linestream(line);
+ linestream >> key;
+ if (key == "procs_running") {
+ linestream >> processes;
+ break;
+ }
+ }
+ }
+ return processes;
+}
 
-// TODO: Read and return the number of active jiffies for the system
-long LinuxParser::ActiveJiffies() { return 0; }
 
-// TODO: Read and return the number of idle jiffies for the system
-long LinuxParser::IdleJiffies() { return 0; }
+// Read and return the command associated with a process
+string LinuxParser::Command(int pid) {
+ string command;
+ std::ifstream stream(kProcDirectory + std::to_string(pid) + kCmdlineFilename);
+ if (stream.is_open()) {
+ std::getline(stream, command);
+ }
+ return command;
+}
 
-// TODO: Read and return CPU utilization
-vector<string> LinuxParser::CpuUtilization() { return {}; }
+// DONE: Read and return the memory used by a process
+string LinuxParser::Ram(int pid) { 
+ string line, label, value; 
+ long ram;
 
-// TODO: Read and return the total number of processes
-int LinuxParser::TotalProcesses() { return 0; }
+ std::ifstream filestream(kProcDirectory + to_string(pid) + kStatusFilename);
+ if (filestream.is_open()) {
+ while (std::getline(filestream, line)) {
+ std::istringstream linestream(line);
+ while (linestream >> label >> value) {
+ if (label == "VmRSS:") {
+ ram = stol(value) / 1000;// convert kilobyte value to megabytes
+ }
+ }
+ }
+ }
+ return to_string(ram); // covert intram into a string
+ ;
+}
 
-// TODO: Read and return the number of running processes
-int LinuxParser::RunningProcesses() { return 0; }
+// DONE: Read and return the user ID associated with a process
+string LinuxParser::Uid(int pid) {
+ string line, label, value, user;
 
-// TODO: Read and return the command associated with a process
-// REMOVE: [[maybe_unused]] once you define the function
-string LinuxParser::Command(int pid[[maybe_unused]]) { return string(); }
+ std::ifstream filestream(kProcDirectory + to_string(pid) + kStatusFilename);
+ if (filestream.is_open()) {
+ while (std::getline(filestream, line)) {
+ std::istringstream linestream(line);
+ while (linestream >> label >> value) {
+ if (label == "Uid:") {
+ user = value;
+ }
+ }
+ }
+ }
+ return user;
+}
+
+// DONE: Read and return the user associated with a process
+string LinuxParser::User(int pid) {
+ string line, label, value, id_value, user;
+ string uid = Uid(pid);
+
+ std::ifstream filestream(kPasswordPath);
+ if (filestream.is_open()) {
+ while (std::getline(filestream, line)) {
+ std::replace(line.begin(), line.end(), ':', ' ');
+ std::istringstream linestream(line);
+ while (linestream >> label >> value >> id_value) {
+ if (id_value == uid) {//this matches the balue to the uid
+ user = label;//gives you the name of the user
+ }
+ }
+ }
+ }
+ return user;
+}
 
-// TODO: Read and return the memory used by a process
-// 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(); }
+// DONE: Read and return the uptime of a process
 
-// 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(); }
 
-// TODO: Read and return the uptime of a process
-// REMOVE: [[maybe_unused]] once you define the function
-long LinuxParser::UpTime(int pid[[maybe_unused]]) { return 0; }
+long LinuxParser::UpTime(int pid) {
+ string line, value;
+ vector<string> ticks {};
+ int upTimePid;
+ std::ifstream filestream(kProcDirectory + to_string(pid) + kStatFilename);
+ if (filestream.is_open()) {
+ while (std::getline(filestream, line)) {
+ std::istringstream linestream(line);
+ while (linestream >> value) {
+ ticks.emplace_back(value);
+ }
+ }
+ }
+ upTimePid = UpTime() - stol(ticks[21]) / sysconf(_SC_CLK_TCK); // return the starttime (in seconds) per stack overflow
+ return upTimePid;
+}