add support for sub-process management (#11)

meson.build

@@ -39,6 +39,7 @@ lib_src = [
  'src/uenv/repository.cpp',
  'src/util/shell.cpp',
  'src/util/strings.cpp',
+ 'src/util/subprocess.cpp',
  'src/uenv/uenv.cpp',
 ]
 lib_inc = include_directories('src')
@@ -79,6 +80,7 @@ unit_src = [
  'test/unit/main.cpp',
  'test/unit/parse.cpp',
  'test/unit/repository.cpp',
+ 'test/unit/subprocess.cpp',
 ]
 
 unit = executable('unit',

src/util/subprocess.cpp

@@ -0,0 +1,140 @@
+#include <string>
+#include <vector>
+
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <util/expected.h>
+#include <util/subprocess.h>
+
+#include <fmt/core.h>
+#include <fmt/ranges.h>
+
+namespace util {
+
+expected<pipe, int> make_pipe() {
+ pipe p;
+ if (auto rval = ::pipe(p.state); rval == -1) {
+ return unexpected(rval);
+ }
+ return p;
+}
+
+expected<subprocess, std::string> run(const std::vector<std::string>& argv) {
+ if (argv.empty()) {
+ return unexpected("need at least one argument");
+ }
+
+ // TODO: error handling
+ pipe inpipe = *make_pipe();
+ pipe outpipe = *make_pipe();
+ pipe errpipe = *make_pipe();
+
+ auto pid = ::fork();
+
+ if (pid == 0) {
+ // TODO: error handling
+ ::dup2(outpipe.write(), STDOUT_FILENO);
+ ::dup2(errpipe.write(), STDERR_FILENO);
+ ::dup2(inpipe.read(), STDIN_FILENO);
+
+ outpipe.close();
+ errpipe.close();
+ inpipe.close();
+
+ // child(argv);
+ std::vector<char*> args;
+ args.reserve(argv.size() + 1);
+ for (auto& arg : argv) {
+ args.push_back(const_cast<char*>(arg.data()));
+ }
+ args.push_back(nullptr);
+
+ execvp(args[0], &args[0]);
+
+ // this code only executes if the attempt to launch the subprocess
+ // fails to launch.
+ std::perror(
+ fmt::format("subprocess error running '{}'", fmt::join(argv, " "))
+ .c_str());
+ exit(1);
+ }
+
+ outpipe.close_write();
+ errpipe.close_write();
+ inpipe.close_read();
+
+ return subprocess{outpipe, errpipe, inpipe, pid};
+}
+
+void subprocess::setrcode(int status) {
+ if (WIFEXITED(status)) {
+ rcode_ = WEXITSTATUS(status);
+ } else if (WIFSIGNALED(status)) {
+ rcode_ = WTERMSIG(status);
+ } else {
+ rcode_ = 255;
+ }
+}
+
+int subprocess::wait() {
+ if (!finished_) {
+ int status = 0;
+ waitpid(pid, &status, 0);
+ finished_ = true;
+ setrcode(status);
+ }
+ return *rcode_;
+}
+
+bool subprocess::finished() {
+ if (finished_) {
+ return true;
+ }
+
+ int status;
+ auto rc = waitpid(pid, &status, WNOHANG);
+ if (rc == 0) {
+ return false;
+ }
+
+ wait();
+
+ return true;
+}
+
+void subprocess::kill(int signal) {
+ if (!finished_) {
+ ::kill(pid, signal);
+ wait();
+ }
+ finished_ = true;
+}
+
+int subprocess::rvalue() {
+ if (!finished_) {
+ return wait();
+ }
+ return *rcode_;
+}
+
+std::istream& buffered_istream::stream() {
+ return *stream_;
+}
+
+std::optional<std::string> buffered_istream::getline() {
+ if (std::string line; std::getline(stream(), line)) {
+ return line;
+ }
+ return {};
+}
+
+std::ostream& buffered_ostream::stream() {
+ return *stream_;
+}
+
+void buffered_ostream::putline(std::string_view line) {
+ stream() << line << std::endl;
+}
+
+} // namespace util

src/util/subprocess.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <ext/stdio_filebuf.h>
+
+#include <util/expected.h>
+
+namespace util {
+
+struct pipe {
+ int state[2];
+ int read() const {
+ return state[0];
+ }
+ int write() const {
+ return state[1];
+ }
+ void close() {
+ ::close(read());
+ ::close(write());
+ }
+ void close_read() {
+ ::close(read());
+ }
+ void close_write() {
+ ::close(write());
+ }
+};
+
+class buffered_istream {
+ std::unique_ptr<__gnu_cxx::stdio_filebuf<char>> buffer_;
+ std::unique_ptr<std::istream> stream_;
+
+ public:
+ buffered_istream() = delete;
+ buffered_istream(const pipe& p)
+ : buffer_(new __gnu_cxx::stdio_filebuf<char>(p.read(),
+ std::ios_base::in, 1)),
+ stream_(new std::istream(buffer_.get())) {
+ }
+
+ std::istream& stream();
+
+ std::optional<std::string> getline();
+};
+
+class buffered_ostream {
+ std::unique_ptr<__gnu_cxx::stdio_filebuf<char>> buffer_;
+ std::unique_ptr<std::ostream> stream_;
+
+ public:
+ buffered_ostream() = delete;
+ buffered_ostream(const pipe& p)
+ : buffer_(new __gnu_cxx::stdio_filebuf<char>(p.write(),
+ std::ios_base::out, 1)),
+ stream_(new std::ostream(buffer_.get())) {
+ }
+
+ std::ostream& stream();
+ void putline(std::string_view line);
+};
+
+enum class proc_status { running, finished };
+
+class subprocess {
+ public:
+ buffered_istream out;
+ buffered_istream err;
+ buffered_ostream in;
+ pid_t pid;
+
+ subprocess() = delete;
+
+ subprocess(buffered_istream out, buffered_istream err, buffered_ostream in,
+ pid_t pid)
+ : out(std::move(out)), err(std::move(err)), in(std::move(in)),
+ pid(pid) {
+ }
+
+ int wait();
+ bool finished();
+ int rvalue();
+ void kill(int signal = 9);
+
+ private:
+ bool finished_ = false;
+ std::optional<int> rcode_;
+ void setrcode(int);
+};
+
+expected<subprocess, std::string> run(const std::vector<std::string>& argv);
+
+} // namespace util

test/unit/subprocess.cpp

@@ -0,0 +1,83 @@
+#include <catch2/catch_all.hpp>
+#include <fmt/core.h>
+
+#include <util/subprocess.h>
+
+namespace matchers = Catch::Matchers;
+
+TEST_CASE("error", "[subprocess]") {
+ // test that execve error is handled correctly by running an binary that
+ // does not exist
+ {
+ auto proc = util::run({"/wombat/soup", "--garbage"});
+ REQUIRE(proc->wait() == 1);
+ auto line = proc->err.getline();
+ REQUIRE(line);
+ REQUIRE_THAT(*line,
+ matchers::ContainsSubstring("No such file or directory"));
+ }
+ // check that errors are handled correctly when an application launches,
+ // then fails with an error
+ {
+ auto proc = util::run({"ls", "--garbage"});
+ // ls returns 2 for "serious trouble, e.g. can't access comand line
+ // argument"
+ REQUIRE(proc->wait() == 2);
+ auto line = proc->err.getline();
+ REQUIRE(line);
+ REQUIRE_THAT(*line,
+ matchers::Equals("ls: unrecognized option '--garbage'"));
+ }
+}
+
+TEST_CASE("wait", "[subprocess]") {
+ Catch::Timer t;
+ // sleep for 100 ms
+ t.start();
+ // wait 50 ms
+ auto proc = util::run({"sleep", "0.1s"});
+ while (t.getElapsedMilliseconds() < 50) {
+ }
+ REQUIRE(!proc->finished());
+ REQUIRE(proc->wait() == 0);
+ REQUIRE(proc->finished());
+ REQUIRE(t.getElapsedMicroseconds() > 100'000);
+}
+
+TEST_CASE("kill", "[subprocess]") {
+ // sleep 100 ms
+ auto proc = util::run({"sleep", "0.1s"});
+ // the following will be called while the process is running
+ proc->kill();
+ REQUIRE(proc->finished());
+ // se set return value to -1 when the process is killed
+ REQUIRE(proc->rvalue() == 9);
+}
+
+TEST_CASE("stdout", "[subprocess]") {
+ {
+ auto proc = util::run({"echo", "hello world"});
+ REQUIRE(proc);
+ REQUIRE(proc->wait() == 0);
+ auto line = proc->out.getline();
+ REQUIRE(line);
+ REQUIRE_THAT(*line, matchers::Equals("hello world"));
+ // only one line of ourput is expected
+ REQUIRE(!proc->out.getline());
+ REQUIRE(!proc->err.getline());
+ }
+ {
+ auto proc = util::run({"echo", "-e", "hello\nworld"});
+ REQUIRE(proc);
+ REQUIRE(proc->wait() == 0);
+ auto line = proc->out.getline();
+ REQUIRE(line);
+ REQUIRE_THAT(*line, matchers::Equals("hello"));
+ line = proc->out.getline();
+ REQUIRE(line);
+ REQUIRE_THAT(*line, matchers::Equals("world"));
+ // only one line of ourput is expected
+ REQUIRE(!proc->out.getline());
+ REQUIRE(!proc->err.getline());
+ }
+}