Merge pull request #16 from PeerPrep/ajay/download-src

Compile and execute code

Author: Manoharan-Ajay-Anand

.vscode/c_cpp_properties.json

@@ -5,7 +5,8 @@
             "includePath": [
                 "${workspaceFolder}/executor/libs/cppevent-base/src",
                 "${workspaceFolder}/executor/libs/cppevent-net/src",
-                "${workspaceFolder}/executor/libs/cppevent-fcgi/src"
+                "${workspaceFolder}/executor/libs/cppevent-fcgi/src",
+                "${workspaceFolder}/executor/src"
             ],
             "defines": [],
             "compilerPath": "/usr/bin/gcc",

.vscode/settings.json

@@ -1,6 +1,63 @@
 {
     "files.associations": {
-        "iosfwd": "cpp"
+        "iosfwd": "cpp",
+        "string_view": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "coroutine": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "map": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "format": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "span": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp"
     },
     "cmake.sourceDirectory": "${workspaceFolder}/executor",
     "cmake.buildDirectory": "${workspaceFolder}/executor/build"

executor/.gitignore

@@ -1 +1,4 @@
-build
+build
+result
+executor
+code_*

executor/CMakeLists.txt

@@ -14,6 +14,8 @@ add_subdirectory(libs/cppevent-fcgi)
 
 add_executable(executor
     src/exec_endpoint.cpp
+    src/child_process.cpp
+    src/util.cpp
     src/main.cpp
 )
 

executor/shell.nix

@@ -6,7 +6,7 @@ mkShell {
   ];
 
   shellHook = ''
-    cd result/bin
+    cp result/bin/executor executor
     ./executor
   '';
 

executor/src/child_process.cpp

@@ -0,0 +1,40 @@
+#include "child_process.hpp"
+
+#include <cppevent_base/event_loop.hpp>
+#include <cppevent_base/event_listener.hpp>
+#include <cppevent_base/util.hpp>
+
+#include <sys/syscall.h>
+#include <sys/wait.h>
+
+class pid_listener {
+private:
+    cppevent::event_listener* const listener;
+public:
+    pid_listener(cppevent::event_loop& e_loop, int fd): listener(e_loop.get_io_listener(fd)) {
+    }
+
+    ~pid_listener() {
+        listener->detach();
+    }
+
+    cppevent::read_awaiter wait_signal() {
+        return cppevent::read_awaiter { *listener };
+    }
+};
+
+cppevent::awaitable_task<bool> executor::await_child_process(int pid_fd,
+                                                             cppevent::event_loop& e_loop) {
+    pid_listener listener(e_loop, pid_fd);
+    
+    siginfo_t info = {};
+    while (waitid(P_PIDFD, pid_fd, &info, WEXITED) == -1) {
+        if (errno == EAGAIN) {
+            co_await listener.wait_signal();
+            continue;
+        }
+        cppevent::throw_error("Error waiting for pid");
+    }
+
+    co_return info.si_status == 0;
+}

executor/src/child_process.hpp

@@ -0,0 +1,18 @@
+#ifndef EXECUTOR_CHILD_PID_HPP
+#define EXECUTOR_CHILD_PID_HPP
+
+#include <cppevent_base/task.hpp>
+
+namespace cppevent {
+
+class event_loop;
+
+}
+
+namespace executor {
+
+cppevent::awaitable_task<bool> await_child_process(int pid_fd, cppevent::event_loop& e_loop);
+
+}
+
+#endif

executor/src/exec_endpoint.cpp

@@ -1,14 +1,117 @@
 #include "exec_endpoint.hpp"
 
-#include <sstream>
+#include "util.hpp"
+
+#include <cerrno>
+#include <cstring>
+#include <cstdlib>
+
+#include <array>
+#include <algorithm>
+#include <unordered_map>
+#include <string_view>
+#include <stdexcept>
+
+#include <cppevent_base/util.hpp>
+
+#include <unistd.h>
+#include <fcntl.h>
+
+constexpr long BUF_LEN = 1024;
+constexpr long MAX_RESPONSE_SIZE = 10 * 1024; 
+
+constexpr std::string_view COMPILE_ERR = "compile_err.out";
+constexpr std::string_view RUN_STDOUT = "run.out";
+
+executor::exec_endpoint::exec_endpoint(cppevent::event_loop& e_loop): m_loop(e_loop) {
+}
+
+cppevent::awaitable_task<void> download(long content_len,
+                                        cppevent::stream& s_stdin,
+                                        int fd) {
+    std::array<uint8_t, BUF_LEN> buffer;
+    while (content_len > 0) {
+        long download_size = std::min(BUF_LEN, content_len);
+        co_await s_stdin.read(buffer.data(), download_size, true);
+        cppevent::throw_if_error(write(fd, buffer.data(), download_size), "Failed to download: ");
+        content_len -= download_size; 
+    }
+}
+
+template <long BUFFER_SIZE>
+bool read_to_buffer(std::array<uint8_t, BUFFER_SIZE>& buffer, long& read_size, int fd) {
+    read_size = read(fd, buffer.data(), BUFFER_SIZE);
+    return read_size > 0;
+}
+
+cppevent::awaitable_task<void> upload(std::string_view dir, std::string_view name,
+                                      cppevent::output& o_stdout) {
+    int fd = executor::open_file(dir, name, O_RDONLY);
+    std::array<uint8_t, BUF_LEN> buffer;
+    long response_size = 0;
+    long read_size;
+    while (response_size < MAX_RESPONSE_SIZE && read_to_buffer<BUF_LEN>(buffer, read_size, fd)) {
+        co_await o_stdout.write(buffer.data(), read_size);
+        response_size += read_size;
+    }
+    close(fd);
+}
+
+const std::unordered_map<std::string_view, std::string_view> source_file_names = {
+    { "cpp", "source.cpp" },
+    { "java", "Source.java" },
+    { "python", "source.py" }
+};
 
 cppevent::awaitable_task<void> executor::exec_endpoint::process(const cppevent::context& cont,
                                                                 cppevent::stream& s_stdin,
                                                                 cppevent::output& o_stdout) {
     auto lang_opt = cont.get_path_segment("lang");
     auto& lang = lang_opt.value();
-    std::stringstream ss;
-    ss << "content-length: " << 6 + lang.size() << "\ncontent-type: text/plain\n\n";
-    ss << "hello " << lang;
-    co_await o_stdout.write(ss.str());
+    long content_len = cont.get_content_len();
+    auto it = source_file_names.find(lang);
+    if (it == source_file_names.end() || content_len == 0) {
+        co_await o_stdout.write("status: 400\ncontent-length: 16\n\nunknown language");
+        co_return;
+    }
+    char dir_name[12];
+    strcpy(dir_name, "code_XXXXXX");
+    if (mkdtemp(dir_name) == NULL) {
+        co_await o_stdout.write("status: 500\ncontent-type: text/plain\n\n");
+        co_await o_stdout.write(strerror(errno));
+        co_return;
+    }
+
+    const std::string_view& source_file_name = it->second;
+    const int source_fd = open_file(dir_name, source_file_name, O_WRONLY | O_CREAT);
+    co_await download(content_len, s_stdin, source_fd);
+    close(source_fd);
+
+    const int compile_err_fd = open_file(dir_name, COMPILE_ERR, O_WRONLY | O_CREAT);
+    bool compiled_success = co_await await_compile(compile_err_fd, m_loop, dir_name, lang);
+    close(compile_err_fd);
+
+    if (!compiled_success) {
+        co_await o_stdout.write("status: 200\nx-exec-status: compile_error\ncontent-type: text/plain\n\n");
+        co_await upload(dir_name, COMPILE_ERR, o_stdout);
+        co_return;
+    }
+
+    const int run_out_fd = open_file(dir_name, RUN_STDOUT, O_WRONLY | O_CREAT);
+    CODE_EXEC_STATUS run_status = co_await await_run(run_out_fd, m_loop, dir_name, lang);
+    close(run_out_fd);
+
+    switch (run_status) {
+        case CODE_EXEC_STATUS::RUN_ERROR:
+            co_await o_stdout.write("status: 200\nx-exec-status: run_error\ncontent-type: text/plain\n\n");
+            break;
+        case CODE_EXEC_STATUS::RUN_TIMEOUT:
+            co_await o_stdout.write("status: 200\nx-exec-status: timeout\ncontent-type: text/plain\n\n");
+            break;
+        case CODE_EXEC_STATUS::RUN_SUCCESS:
+            co_await o_stdout.write("status: 200\nx-exec-status: success\ncontent-type: text/plain\n\n");
+            break;
+    }
+
+    co_await upload(dir_name, RUN_STDOUT, o_stdout);
 }

executor/src/exec_endpoint.hpp

@@ -3,10 +3,22 @@
 
 #include <cppevent_fcgi/endpoint.hpp>
 
+#include <string_view>
+
+namespace cppevent {
+
+class event_loop;
+
+}
+
 namespace executor {
 
 class exec_endpoint : public cppevent::endpoint {
+private:
+    cppevent::event_loop& m_loop;
 public:
+    exec_endpoint(cppevent::event_loop& e_loop);
+
     cppevent::awaitable_task<void> process(const cppevent::context& cont,
                                                  cppevent::stream& s_stdin,
                                                  cppevent::output& o_stdout);

executor/src/main.cpp

@@ -10,7 +10,7 @@
 int main() {
     cppevent::event_loop e_loop;
     cppevent::router routes;
-    executor::exec_endpoint exec;
+    executor::exec_endpoint exec(e_loop);
     routes.post("/api/v1/execute/{lang}", exec);
     cppevent::fcgi_server server("0.0.0.0", "9000", e_loop, routes);
     std::cout << "Starting executor service" << std::endl;