Add BubbleWrap backend

src/config.cpp

@@ -1,32 +1,31 @@
 #include "config.hpp"
 
+std::vector<sk::host> sk::config::loadHostsFromToml(const fs::path &confFile) {
+    std::vector<sk::host> hosts;
 
-std::vector<sk::host> sk::config::loadHostsFromToml(const fs::path& confFile) {
-	std::vector<sk::host> hosts;
-	
-	auto config = toml::parse_file( confFile.string() );
-	toml::table *serverSection = config.get_as<toml::table>("serveurs");
-	if (serverSection == nullptr) {
-		return hosts;
-	}
+    auto config = toml::parse_file(confFile.string());
+    toml::table *serverSection = config.get_as<toml::table>("serveurs");
+    if (serverSection == nullptr) {
+        return hosts;
+    }
 
     // Parcourir les serveurs
-    for (const auto& [serverNameKey, serverInfoValue] : *serverSection) {
-         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")){
-          	std::string serverIp = serverInfo.get_as<std::string>("ip")->get();
-          	int serverMaxContainers = serverInfo.get_as<int64_t>("nbContainerMax")->get();
-
-			hosts.push_back(sk::host(serverIp,serverMaxContainers));
-		 }
-	}
-
-	return hosts;
+    for (const auto &[serverNameKey, serverInfoValue] : *serverSection) {
+        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")) {
+            std::string serverIp = serverInfo.get_as<std::string>("ip")->get();
+            int serverMaxContainers =
+                serverInfo.get_as<int64_t>("nbContainerMax")->get();
+
+            hosts.push_back(sk::host(serverIp, serverMaxContainers));
+        }
+    }
+
+    return hosts;
 }
-

src/config.hpp

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

src/host.hpp

@@ -13,7 +13,7 @@ class host {
     host(const std::string &ip, unsigned int connectionsMax);
     void addConnection();
 
-    const std::string& getIp() const;
+    const std::string &getIp() const;
 
     unsigned int getNbConnections() const;
     unsigned int getNbConnectionsMax() const;

src/main.cpp

@@ -1,28 +1,48 @@
+#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"
 
-int main() {
-	std::vector<sk::host> hosts = sk::config::loadHostsFromToml("../conf.toml");
+namespace fs = std::filesystem;
 
-	if(hosts.empty()){
-		std::cerr<<"Pas de host"<<std::endl;
-	}
+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");
 
-	for(const auto &host : hosts){
-		std::cout<<host.getIp() <<" "<<host.getNbConnectionsMax()<<std::endl;
-	}
+    if (hosts.empty()) {
+        std::cerr << "Pas de host" << 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,18 +30,29 @@ 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",
-                                "run",
-                                "--rm",
-                                "-i",
-                                "--pull=never",
-                                "--cap-drop=ALL",
-                                "--network=none",
-                                "--memory=64m",
-                                "--memory-swap=64m",
-                                "--pids-limit=128",
-                                program.image.c_str(),
-                                nullptr};
+    const char *const docker_args[] = {"docker",
+                                       "run",
+                                       "--rm",
+                                       "-i",
+                                       "--pull=never",
+                                       "--cap-drop=ALL",
+                                       "--network=none",
+                                       "--memory=64m",
+                                       "--memory-swap=64m",
+                                       "--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);
 };
 }