Add BubbleWrap backend

src/config.cpp

@@ -1,6 +1,5 @@
 #include "config.hpp"
 
-
 std::vector<sk::host> sk::config::loadHostsFromToml(const fs::path &confFile) {
     std::vector<sk::host> hosts;
 
@@ -15,13 +14,14 @@ std::vector<sk::host> sk::config::loadHostsFromToml(const fs::path& confFile) {
         std::string serverName{serverNameKey};
         toml::table *serverInfoPtr = serverInfoValue.as_table();
         if (serverInfoPtr == nullptr) {
-
         }
         toml::table &serverInfo = *serverInfoPtr;
 
-		 if(serverInfo.get_as<std::string>("ip") && serverInfo.get_as<int64_t>("nbContainerMax")){
+        if (serverInfo.get_as<std::string>("ip") &&
+            serverInfo.get_as<int64_t>("nbContainerMax")) {
             std::string serverIp = serverInfo.get_as<std::string>("ip")->get();
-          	int serverMaxContainers = serverInfo.get_as<int64_t>("nbContainerMax")->get();
+            int serverMaxContainers =
+                serverInfo.get_as<int64_t>("nbContainerMax")->get();
 
             hosts.push_back(sk::host(serverIp, serverMaxContainers));
         }
@@ -29,4 +29,3 @@ std::vector<sk::host> sk::config::loadHostsFromToml(const fs::path& confFile) {
 
     return hosts;
 }
-

src/config.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <filesystem>
-#include <vector>
 #include <toml++/toml.h>
+#include <vector>
 
 #include "host.hpp"
 namespace fs = std::filesystem;
@@ -11,6 +11,5 @@ namespace sk{
 class config {
   public:
     static std::vector<sk::host> loadHostsFromToml(const fs::path &confFile);
-
 };
 }

src/main.cpp

@@ -1,11 +1,35 @@
+#include "config.hpp"
 #include "program.hpp"
 #include "runner.hpp"
+#include <filesystem>
 #include <iostream>
 #include <queue>
+#include <spawn.h>
+#include <string_view>
+#include <toml++/toml.h>
 #include <vector>
+#include <wait.h>
 
 #include "host.hpp"
-#include "config.hpp"
+
+namespace fs = std::filesystem;
+
+sk::runner_backend detect_backend() {
+    const char *const argv[] = {"docker", "stats", "--no-stream", nullptr};
+    pid_t pid;
+    if (posix_spawnp(&pid, argv[0], nullptr, nullptr,
+                     const_cast<char *const *>(argv), nullptr) != 0) {
+        return sk::runner_backend::BubbleWrap;
+    }
+    int status = 0;
+    waitpid(pid, &status, 0);
+    std::cout << status << std::endl;
+    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
+        std::cerr << "Using Docker" << std::endl;
+        return sk::runner_backend::Docker;
+    }
+    return sk::runner_backend::BubbleWrap;
+}
 
 int main() {
     std::vector<sk::host> hosts = sk::config::loadHostsFromToml("../conf.toml");
@@ -14,15 +38,11 @@ int main() {
         std::cerr << "Pas de host" << std::endl;
     }
 
-	for(const auto &host : hosts){
-		std::cout<<host.getIp() <<" "<<host.getNbConnectionsMax()<<std::endl;
-	}
-
     std::queue<sk::program> queue;
     queue.push(sk::program{"echo $(( 1 + 2 ))",
                            "ghcr.io/moshell-lang/moshell:master"});
 
-    sk::runner runner;
+    sk::runner runner(detect_backend());
     while (!queue.empty()) {
         const sk::program &current = queue.front();
         sk::run_result res = runner.run_blocking(current);

src/runner.cpp

@@ -9,6 +9,8 @@
 #include <wait.h>
 
 namespace sk {
+runner::runner(runner_backend backend) : backend{backend} {}
+
 run_result runner::run_blocking(const program &program) {
     int in_pipe[2];
     int out_pipe[2];
@@ -28,7 +30,7 @@ run_result runner::run_blocking(const program &program) {
     posix_spawn_file_actions_addclose(&actions, in_pipe[0]);
     posix_spawn_file_actions_addclose(&actions, out_pipe[1]);
     posix_spawn_file_actions_addclose(&actions, err_pipe[1]);
-    const char *const args[] = {"docker",
+    const char *const docker_args[] = {"docker",
                                        "run",
                                        "--rm",
                                        "-i",
@@ -40,6 +42,17 @@ run_result runner::run_blocking(const program &program) {
                                        "--pids-limit=128",
                                        program.image.c_str(),
                                        nullptr};
+    const char *const bwrap_args[] = {
+        "bwrap",     "--ro-bind", "/usr",      "/usr",      "--dir",
+        "/tmp",      "--dir",     "/var",      "--proc",    "/proc",
+        "--dev",     "/dev",      "--symlink", "usr/lib",   "/lib",
+        "--symlink", "usr/lib64", "/lib64",    "--symlink", "usr/bin",
+        "/bin",      "--symlink", "usr/sbin",  "/sbin",     "--unshare-all",
+        "/bin/sh",   nullptr};
+    const char *const *args = docker_args;
+    if (backend == runner_backend::BubbleWrap) {
+        args = bwrap_args;
+    }
     pid_t pid;
     int exit_code;
     if (posix_spawnp(&pid, args[0], &actions, nullptr,

src/runner.hpp

@@ -4,13 +4,18 @@
 #include <string>
 
 namespace sk {
-struct run_result {
+struct [[nodiscard]] run_result {
     std::string out;
     std::string err;
 };
 
+enum class runner_backend { BubbleWrap, Docker };
+
 class runner {
+    runner_backend backend;
+
   public:
+    explicit runner(runner_backend backend);
     run_result run_blocking(const program &program);
 };
 }