commit

CMakeLists.txt

@@ -5,6 +5,14 @@ project(planificador)
 add_compile_options(-Wall -Wextra -pedantic)
 
 include(FetchContent)
+
+FetchContent_Declare(
+    rpclib
+    GIT_REPOSITORY https://github.com/rpclib/rpclib.git
+    GIT_TAG        master
+)
+FetchContent_MakeAvailable(rpclib)
+
 FetchContent_Declare(
     tomlplusplus
     GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
@@ -12,8 +20,13 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(tomlplusplus)
 
-file(GLOB nameFile "src/*.cpp")
-add_executable(planificador src/host.cpp src/runner.cpp src/config.cpp src/main.cpp )
+add_executable(planificador src/host.cpp src/runner.cpp src/config.cpp src/main.cpp)
 target_compile_features(planificador PUBLIC cxx_std_17)
 
 include_directories(${tomlplusplus_SOURCE_DIR}/include)
+include_directories(${rpclib_SOURCE_DIR}/include)
+
+SET(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+target_link_libraries(planificador PRIVATE Threads::Threads)
+target_link_libraries(planificador PRIVATE rpc)

src/host.cpp

@@ -4,20 +4,14 @@ namespace sk {
 host::host(const std::string &ip, unsigned int connectionsMax)
     : ip{ip}, connections{0}, connectionsMax{connectionsMax}, runners{} {}
 
-void host::addConnection(sk::runner& runner) {
+void host::addConnection(sk::runner &runner) {
     runners.push(runner);
     connections += 1;
 }
 
-const std::string& host::getIp() const {
-    return ip;
-}
+const std::string &host::getIp() const { return ip; }
 
-unsigned int host::getNbConnections() const {
-    return connections; 
-}
+unsigned int host::getNbConnections() const { return connections; }
 
-unsigned int host::getNbConnectionsMax() const {
-    return connectionsMax; 
-}
+unsigned int host::getNbConnectionsMax() const { return connectionsMax; }
 }

src/host.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <string>
+#include "runner.hpp"
 #include <queue>
-#include "runner.hpp" 
+#include <string>
 
 namespace sk {
 class host {
@@ -15,7 +15,7 @@ class host {
 
   public:
     host(const std::string &ip, unsigned int connectionsMax);
-    void addConnection(sk::runner& runner);
+    void addConnection(sk::runner &runner);
 
     const std::string &getIp() const;
 

src/main.cpp

@@ -1,6 +1,4 @@
-#include "config.hpp"
-#include "program.hpp"
-#include "runner.hpp"
+
 #include <filesystem>
 #include <iostream>
 #include <queue>
@@ -9,8 +7,17 @@
 #include <toml++/toml.h>
 #include <vector>
 #include <wait.h>
+#include <thread>
 
 #include "host.hpp"
+#include "rpc/server.h"
+#include "rpc/this_handler.h"
+#include "config.hpp"
+#include "program.hpp"
+#include "runner.hpp"
+
+#include <chrono>
+
 
 namespace fs = std::filesystem;
 
@@ -31,24 +38,53 @@ sk::runner_backend detect_backend() {
     return sk::runner_backend::BubbleWrap;
 }
 
+
+void mainLoop(std::queue<sk::program>& programLists){
+    while(true){
+        auto now = std::chrono::system_clock::now();
+        std::time_t now_time = std::chrono::system_clock::to_time_t(now);
+        std::cout<<std::ctime(&now_time)<<" "<<programLists.size()<<std::endl;
+        if (programLists.size() == 1)
+            exit(0);
+    }
+}
+
 int main() {
     std::vector<sk::host> listsHosts = sk::config::loadHostsFromToml("../conf.toml");
     std::priority_queue<sk::host> hosts(listsHosts.begin(), listsHosts.end());
 
+    std::queue<sk::program> programLists;
+
     if (hosts.empty()) {
         std::cerr << "Pas de host" << std::endl;
+        exit(1);
     }
 
-    std::queue<sk::program> queue;
-    queue.push(sk::program{"echo $(( 1 + 2 ))", "ghcr.io/moshell-lang/moshell:master"});
+    std::thread workerThread(mainLoop, std::ref(programLists));
+
+    rpc::server srv(9000);
+
+    srv.bind("add", [&hosts, &programLists](const std::string &prog, const std::string &image) {
+        programLists.push(sk::program{prog, image});
+
+        const sk::program &currentProgram = programLists.front();
+        const sk::host &currentHost = hosts.top();
+        sk::runner runner(detect_backend());
+
 
-    sk::runner runner(detect_backend());
-    while (!queue.empty()) {
-        const sk::program &current = queue.front();
-        sk::run_result res = runner.run_blocking(current);
+        sk::run_result res = runner.run_blocking(currentProgram);
         std::cout << "out: " << res.out << "\n";
         std::cout << "err: " << res.err << "\n";
-        queue.pop();
-    }
+        programLists.pop();
+
+        if (res.err != "") {
+            rpc::this_handler().respond_error(res.err);
+        }
+
+        return res.out;
+    });
+
+    srv.run();
+
     return 0;
 }