Process value (instead of stateful object). Can find all process on machine via ps

Author: Tony Hannan

Jamroot

@@ -1,6 +1,7 @@
 project : source-location src : requirements <include>/opt/local/include <variant>release ;
 
 lib dl : : <name>dl ;
+lib cr : : <name>crypto ;
 lib sys : : <name>boost_system-mt <search>/opt/local/lib ;
 lib fs : : <name>boost_filesystem-mt <search>/opt/local/lib ;
 lib th : : <name>boost_thread-mt <search>/opt/local/lib ;
@@ -25,7 +26,7 @@ cpp-pch unit : unit.h : <optimization>off ;
 cpp-pch util : util.h : <optimization>off ;
 cpp-pch vector : vector.h : <optimization>off ;
 
-lib 10util : [ glob *.cpp ] dl sys fs th ser ;
+lib 10util : [ glob *.cpp ] dl cr sys fs th ser ;
 
 install ilib : 10util : <location>/usr/local/lib ;
 install ihead : [ glob *.h ]

SConstruct

@@ -4,7 +4,7 @@ lib = SharedLibrary (libname, Glob('src/*.cpp'),
 	CCFLAGS = ['-pg', '-rdynamic'],
 	CPPPATH = ['.', '/opt/local/include'],
 	LIBPATH = ['/opt/local/lib'],
-	LIBS = Split ('dl boost_system-mt boost_thread-mt boost_filesystem-mt boost_serialization-mt') )
+	LIBS = Split ('dl crypto boost_system-mt boost_thread-mt boost_filesystem-mt boost_serialization-mt') )
 
 Alias ('install', '/usr/local')
 Install ('/usr/local/lib', lib)

src/file.cpp

@@ -5,6 +5,8 @@
 #include <unistd.h>
 #include <stdexcept>
 
+using namespace std;
+
 Pipe makePipe () {
 	int pipeFds[2];
 	int ok = pipe (pipeFds);
@@ -15,7 +17,7 @@ Pipe makePipe () {
 	return p;
 }
 
-FD openFile (std::string filename, int openFlags, int openMode) {
+FD openFile (string filename, int openFlags, int openMode) {
 	FD fd = open (filename.c_str(), openFlags, openMode);
 	if (fd == -1) throw std::runtime_error ("Failure opening " + filename + ": " + to_string(errno));
 	return fd;
@@ -30,3 +32,16 @@ void dupFd (FD from, FD to) {
 	int ok = dup2 (from, to);
 	if (ok == -1) throw std::runtime_error ("Failure duplicating FD from " + to_string(from) + " to " + to_string(to) + ": " + to_string(errno));
 }
+
+/** Return next line or NULL if EOF */
+boost::optional<string> fGetLine (FILE* file) {
+	string s;
+	int c;
+	while (true) {
+		c = fgetc (file);
+		if (c == '\n' || c == EOF) break;
+		s.push_back (c);
+	}
+	if (c == EOF && s.empty()) return boost::none;
+	return s;
+}

src/file.h

@@ -4,6 +4,8 @@
 
 #include <string>
 #include <fcntl.h>
+#include <cstdio>
+#include <boost/optional.hpp>
 
 typedef int FD; // File descriptor
 typedef FD FDW; // Write-only file descriptor
@@ -24,3 +26,11 @@ void closeFd (FD fd);
 
 /** Throw exception on error */
 void dupFd (FD from, FD to);
+
+/** Convert FD to FILE*. mode must be same that FD was open it ("r" or "w") */
+// FILE* fdopen (FD fd, const char *mode);
+
+// fclose (FILE*)
+
+/** Return next line or NULL if EOF */
+boost::optional<std::string> fGetLine (FILE* file);

src/process.cpp

@@ -3,38 +3,76 @@
 #include "file.h"
 #include <sys/wait.h>
 #include <signal.h>
+#include <cerrno>
+#include <boost/algorithm/string.hpp>
 
-template <> module::Module type<process::Process_>::module = process::module;
+using namespace std;
 
-static void start (bool clear, process::Process proc) {
-	FDW out = openFile (proc->outFilename(), O_WRONLY | O_CREAT | (clear ? O_TRUNC : O_APPEND), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-	program::IO io (0, out, 2);
-	proc->pid = program::start (clear, proc->program, io);
-	closeFd (out); // child process already duplicated it
-	std::cout << (clear ? "launch " : "restart ") << proc->id << "(" << proc->pid << ")" << ": ";
-	std::cout << proc->program << (clear ? " > " : " >> ") << proc->outFilename() << std::endl;
+template <> module::Module type<process::Process>::module = process::module;
+
+/** Log filename is derived (using md5) from program name its options, so each program will have a different but reproducible log filename. Pid is not included because we don't want the log filename to change when the process is restarted. */
+string process::logFilename (program::Program program) {
+	return program::md5Name (program) + ".log";
 }
 
-static volatile unsigned nextProcessId;
+namespace process {
+Process start (bool clear, program::Program program) {
+	string logFile = process::logFilename (program);
+	FDW log = openFile (logFile, O_WRONLY | O_CREAT | (clear ? O_TRUNC : O_APPEND), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+	program::IO io (0, log, log);
+	pid_t pid = program::start (clear, program, io);
+	closeFd (log); // child process already duplicated it
+	cout << (clear ? "launch " : "restart ") << pid << " " << program << (clear ? " &> " : " &>> ") << logFile << endl;
+	return process::Process (program, pid);
+}
+}
 
 /** Launch program with its stdout redirected to a local file named executable-id */
-process::Process process::launch (program::Program program) {
-	Process proc (new Process_ (program, ++ nextProcessId));
-	start (true, proc);
-	return proc;
-}
+process::Process process::launch (program::Program program) {return process::start (true, program);}
 
 /** Restart program under same process object. Process must not already be running. */
-void process::restart (Process process) {start (false, process);}
+process::Process process::restart (program::Program program) {return process::start (false, program);}
 
 /** Wait for process to terminate returning its exit code */
 int process::waitFor (Process process) {
 	int status;
-	waitpid (process->pid, &status, 0);
+	waitpid (process.pid, &status, 0);
 	return status;
 }
 
-void process::signal (Signal s, Process p) {kill (p->pid, s);}
+void process::signal (Signal s, Process p) {kill (p.pid, s);}
 
 /** Kill process. No-op if already dead */
 void process::terminate (Process p) {signal (SIGTERM, p);}
+
+static const program::Program ps ("", "ps", program::options ("e", "", "o", "pid=", "o", "command="));
+
+static boost::optional<process::Process> parsePSLine (string line) {
+	if (line.empty()) return boost::none;
+	vector<string> args;
+	boost::split (args, line, boost::is_any_of (" "));
+	args.erase (remove (args.begin(), args.end(), ""), args.end());
+	if (args.size() < 2) throw runtime_error (to_string (ps) + " produced unexpected output: " + line);
+	pid_t pid = parse_string<pid_t> (args[0]);
+	string executable = args[1];
+	if (executable[0] == '(') return boost::none; // dead processes are surrounded by parens (at least on Mac OSX)
+	args.erase (args.begin(), args.begin() + 2);
+	program::Options options = program::parseArgs (args);
+	return process::Process (program::Program ("", executable, options), pid);
+}
+
+/** Return all processes running on local machine. Note, they will be missing their program prepCommand. */
+vector<process::Process> process::allProcesses () {
+	Pipe pipe = makePipe();
+	program::IO io (0, pipe.writeEnd, 2);
+	pid_t pid = program::start (false, ps, io);
+	closeFd (pipe.writeEnd);
+	FILE* in = fdopen (pipe.readEnd, "r");
+	vector<process::Process> procs;
+	while (boost::optional<string> line = fGetLine (in)) {
+		boost::optional<process::Process> p = parsePSLine (*line);
+		if (p) procs.push_back (*p);
+	}
+	fclose (in);
+	return procs;
+}

src/process.h

@@ -4,8 +4,6 @@
 
 #include <signal.h>
 #include <iostream>
-#include <boost/algorithm/string.hpp>
-#include <boost/shared_ptr.hpp>
 #include "program.h"
 #include "util.h" // to_string
 #include "module.h"
@@ -14,44 +12,36 @@ namespace process {
 
 const module::Module module ("10util", "10util/process.h");
 
-/** Process running a Program */
-class Process_ {
-public:
+struct Process {
 	program::Program program;
-	unsigned id; // our id, not OS id
-	pid_t pid; // OS id
-	Process_ (program::Program program, unsigned id) : program(program), id(id) {}
-	Process_ () {}  // for serialization
-	std::string shortName () const {
-		std::vector<std::string> parts;
-		boost::split (parts, program.executable, boost::is_any_of ("/"));
-		return *--parts.end() + "-" + to_string (id);
-	}
-	std::string outFilename () const {return shortName() + ".out";}
+	pid_t pid;
+	Process (program::Program program, pid_t pid) : program(program), pid(pid) {}
 };
 
-typedef boost::shared_ptr<Process_> Process;
+/** Log filename is derived (using md5) from program name its options, so each program will have a different but reproducible log filename. Pid is not included because we don't want the log filename to change when the process is restarted. */
+std::string logFilename (program::Program);
 
 /** Launch program with its stdout redirected to a local file named executable-id */
-Process launch (program::Program program);
+Process launch (program::Program);
 
 /** Restart program (does not run prepCommand first) */
-void restart (Process deadProcess);
+Process restart (program::Program);
 
 /** Wait for process to terminate returning its exit code */
-int waitFor (Process process);
+int waitFor (Process);
 
 typedef int Signal;
 
 /** Send signal to process. No-op if process dead */
 void signal (Signal, Process);
 
 /** Kill process. No-op if already dead */
-void terminate (Process p);
+void terminate (Process);
 
-/** Program process is running */
-inline program::Program program (Process process) {return process->program;}
+/** Return all processes running on local machine. They will be missing their program prepCommand. */
+std::vector<Process> allProcesses ();
 
 }
 
-inline std::ostream& operator<< (std::ostream& out, const process::Process_& p) {out << p.shortName(); return out;}
+inline std::ostream& operator<< (std::ostream& out, const process::Process& p) {
+	out << p.pid << " " << p.program; return out;}