initial commit? i wrote a lot for an initial commit lmao

Author: pnappa

Makefile

@@ -0,0 +1,4 @@
+
+demo: demo.cpp subprocess.hpp
+	g++ -g -std=c++14 demo.cpp -o demo -lpthread
+

README.md

@@ -0,0 +1,60 @@
+# SubprocessCPP
+
+A neat header-only library that allows you to execute processes either synchronously or asynchronously, whilst providing input and handling the generated input. No more calling `exec` in a C++ program!
+
+This library uses some C++11 features, and tries to be as idiomatic to modern C++.
+
+# Usage
+Simply include the `subprocess.hpp` file.
+
+An example program is provided in `demo.cpp`, but here's some snippets:
+
+```C++
+// execute bc and pass it some equations
+std::list<std::string> inputs = {"1+1\n", "2^333\n", "32-32\n"};
+subprocess::execute("/usr/bin/bc", 
+                          {}, 
+                          inputs, 
+                          echoString);
+
+// grep over some inputs
+inputs = {"12232\n", "hello, world\n", "Hello, world\n\n", "line: Hello, world!\n"};
+subprocess::execute("/bin/grep", {"-i", "Hello, world"}, inputs, echoString);
+
+// execute a process and extract all lines outputted
+inputs.clear(); // provide no stdin
+int status;
+std::vector<std::string> vec = subprocess::checkOutput("/usr/bin/time", {"sleep", "1"}, inputs, status);
+for (const std::string& s : vec) {
+    std::cout << "output: " << s << '\t';
+    std::cout << "line length:" << s.length() << std::endl;
+}
+std::cout << "process finished with an exit code of: " << status << std::endl;
+
+// execute sleep asynchronously, and block when needing the output
+std::future<int> futureStatus = subprocess::async("/bin/sleep", {"3"}, inputs, [](std::string) {});
+// if this wasn't async, this wouldn't print until after the process finished!
+std::cout << "executing sleep..." << std::endl;
+std::cout << "sleep executed with exit status: " << futureStatus.get() << std::endl;
+```
+
+# Requirements
+Not much:
+ - A POSIX environment (Linux, Mac, \*BSD)
+ - A modern >=C++11 compiler
+
+Unfortunately, I am not as familiar with Windows to write code for it, if you want to provide some code that works for this platform, be my guest! But, don't forget to include appropriate header guards so that it works cross-platform.
+
+# API
+### TODO: ....detail what each of the functions _should_ be used for.
+
+# License
+This is dual-licensed under a MIT and GPLv3 license - so FOSS lovers can use it, whilst people restricted in companies to not open-source their program is also able to use this library :)
+
+I don't know too much about licenses, so if I missed anything, please let me know.
+
+# Future Features
+Some stuff that I haven't written yet, but I wanna:
+ - [X] Output streaming. Provide an iterator to allow iteration over the output lines, such that we don't have to load all in memory at once.
+ - [ ] Thread-safe async lambda interactions. Provide a method to launch a process in async, but still allow writing to the list of stdin without a race condition.
+ - [ ] A ping-ponging interface. This should allow incrementally providing stdin, then invoking the functor if output is emitted. Note that will likely not be possible if there's not performed asynchronously, or without using select. Using select is a bit annoying, because how do we differentiate between a command taking a while and it providing no input?

demo.cpp

@@ -0,0 +1,42 @@
+#include <list>
+#include <string>
+#include <iostream>
+
+#include "subprocess.hpp"
+
+void echoString(std::string in) {
+    std::cout << "output: " << in;
+}
+
+int main() {
+    // execute bc and pass it some equations
+    std::list<std::string> inputs = {"1+1\n", "2^333\n", "32-32\n"};
+    subprocess::execute("/usr/bin/bc", 
+                              {}, 
+                              inputs, 
+                              echoString);
+
+    // grep over some inputs
+    inputs = {"12232\n", "hello, world\n", "Hello, world\n\n", "line: Hello, world!\n"};
+    subprocess::execute("/bin/grep", {"-i", "Hello, world"}, inputs, echoString);
+
+    // execute a process and extract all lines outputted
+    inputs.clear(); // provide no stdin
+    int status;
+    std::vector<std::string> vec = subprocess::checkOutput("/usr/bin/time", {"sleep", "1"}, inputs, status);
+    for (const std::string& s : vec) {
+        std::cout << "output: " << s << '\t';
+        std::cout << "line length:" << s.length() << std::endl;
+    }
+    std::cout << "process finished with an exit code of: " << status << std::endl;
+
+    // execute sleep asynchronously, and block when needing the output
+    // you will not be able to modify inputs dynamically from the functor, due to the possibility of concurrent modification of the list & line feeder
+    std::future<int> futureStatus = subprocess::async("/bin/sleep", {"3"}, inputs, [](std::string) {});
+    // if this wasn't async, this wouldn't print until after the process finished!
+    std::cout << "executing sleep..." << std::endl;
+    std::cout << "sleep executed with exit status: " << futureStatus.get() << std::endl;
+
+
+    // simulate pipes between programs: lets launch echo to provide input into a grep process!
+}

subprocess.hpp

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <string>
+#include <stdexcept>
+#include <iostream>
+#include <algorithm>
+#include <functional>
+#include <tuple>
+#include <vector>
+#include <list>
+#include <future>
+
+// unix process stuff
+#include <signal.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <sys/prctl.h>
+#include <cstring>
+
+
+
+namespace subprocess {
+
+/* execute a process, inputting stdin and calling the functor with the stdout lines.
+ * returns the status code of the executed program
+ * */
+
+int execute(const std::string& commandPath, 
+        const std::vector<std::string>& commandArgs, 
+        std::list<std::string>& stringInput /* what pumps into stdin */,
+        std::function<void(std::string)> lambda) {
+    // based off https://stackoverflow.com/a/6172578
+    pid_t pid = 0;
+    int inpipefd[2];
+    int outpipefd[2];
+
+    
+    // construct the argument list (unfortunately, the C api wasn't defined with C++ in mind, so we have to abuse const_cast)
+    // see: https://stackoverflow.com/a/190208
+    std::vector<char*> cargs;
+    // the process name must be first for execv
+    cargs.push_back(const_cast<char*>(commandPath.c_str()));
+    for (const std::string& arg : commandArgs) {
+        cargs.push_back(const_cast<char*>(arg.c_str()));
+    }
+    // must be terminated with a nullptr for execv
+    cargs.push_back(nullptr);
+
+    pipe(inpipefd);
+    pipe(outpipefd);
+    pid = fork();
+    // child
+    if (pid == 0) {
+        dup2(outpipefd[0], STDIN_FILENO);
+        dup2(inpipefd[1], STDOUT_FILENO);
+        dup2(inpipefd[1], STDERR_FILENO);
+
+        // XXX: test (close the stdin..?)
+        close(outpipefd[1]);
+
+        //ask kernel to deliver SIGTERM in case the parent dies
+        prctl(PR_SET_PDEATHSIG, SIGTERM);
+        
+        execv(commandPath.c_str(), cargs.data());
+        // Nothing below this line should be executed by child process. If so, 
+        // it means that the execl function wasn't successfull, so lets exit:
+        exit(1);
+    }
+
+    close(outpipefd[0]);
+    close(inpipefd[1]);
+
+    // while our string queue is working, 
+    while (!stringInput.empty()) {
+        // write our input to the process's stdin pipe
+        std::string newInput = stringInput.front();
+        stringInput.pop_front();
+        write(outpipefd[1], newInput.c_str(), newInput.size());
+    }
+    // now we finished chucking in the string, send an EOF
+    close(outpipefd[1]);
+
+    // iterate over each line output by the child's stdout, and call the functor
+    FILE* childStdout = fdopen(inpipefd[0], "r");
+    char* line = nullptr;
+    ssize_t nread;
+    size_t len;
+    while ((nread = getline(&line, &len, childStdout)) != -1) {
+        lambda(std::string(line)); 
+
+        // free up the memory allocated by getline
+        free(line);
+        line = nullptr;
+    }
+    if (line != nullptr) free(line);
+
+    fclose(childStdout);
+    int status;
+    waitpid(pid, &status, 0);
+
+    return status;
+}
+
+/* convenience fn to return a list of outputted strings */
+std::vector<std::string> checkOutput(const std::string& commandPath, 
+        const std::vector<std::string>& commandArgs, 
+        std::list<std::string>& stringInput /* what pumps into stdin */,
+        int& status) {
+    std::vector<std::string> retVec;
+    status = execute(commandPath, commandArgs, stringInput, [&](std::string s) { retVec.push_back(std::move(s)); });
+    return retVec;
+}
+
+/* spawn the process in the background asynchronously, and return a future of the status code */
+std::future<int> async(const std::string commandPath, const std::vector<std::string> commandArgs, std::list<std::string> stringInput, std::function<void(std::string)> lambda) {
+    // spawn the function async - we must pass the args by value into the async lambda
+    // otherwise they may destruct before the execute fn executes!
+    // whew, that was an annoying bug to find...
+    return std::async(std::launch::async, 
+            [&](const std::string cp, 
+                const std::vector<std::string> ca,
+                std::list<std::string> si,
+                std::function<void(std::string)> l) { return execute(cp, ca, si, l); }, commandPath, commandArgs, stringInput, lambda);
+}
+
+} // end namespace subprocess