feat: Add initial version of the code-runner with only few languages

Author: johnnyeric

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "code-runner-rust"
+version = "0.1.0"
+authors = ["Johnny Eric Amancio <johnnyeric@gmail.com>"]
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_derive = "1.0"
+serde_json = "1.0"
+phf = { version = "0.7.24", features = ["macros"] }
+tempfile = "3"

README.md

@@ -1,2 +1,112 @@
 # code-runner-rust
-Code Runner written in Rust
+
+This is my attempt to port the [glot-code-runner](https://github.com/prasmussen/glot-code-runner) to Rust.
+
+## Overview
+code-runner-rust is a command line application that reads code as a
+json payload from stdin – compiles and runs the code – and writes
+the result as json to stdout.
+
+## Prerequisites
+code-runner-rust requires that the compiler / interpreter for the languages
+you want to run is installed and is in PATH.
+
+## Supported languages
+- golang
+- javascript
+- python
+- rust
+
+## Input (stdin)
+The input is required to be a json object containing the properties `language`
+and `files`. `language` must be a lowecase string matching one of the supported
+languages. `files` must be an array with at least one object containing the
+properties `name` and `content`. `name` is the name of the file and can include
+forward slashes to create the file in a subdirectory relative to the base
+directory. All files are written into the same base directory under the OS's
+temp dir.
+
+In addition, one may optionally provide the `stdin` and `command` properties to
+provide stdin data to the running code and to run the code with a custom command.
+See examples below.
+
+## Output (stdout)
+The output is a json object containing the properties `stdout`, `stderr` and
+`error`. `stdout` and `stderr` is captured from the output of the ran code.
+`error` is popuplated if there is a compiler / interpreter error.
+Note that glot-code-runner will exit with a non-zero code if invalid input is
+given or if the files cannot be written to disk (permissions, disk space, etc).
+No json will be written to stdout in those cases. Otherwise the exit code is 0.
+
+## Examples
+
+### Simple example
+##### Input
+```javascript
+{
+  "language": "python",
+  "files": [
+    {
+      "name": "main.py",
+      "content": "print(42)"
+    }
+  ]
+}
+```
+
+##### Output
+```javascript
+{
+  "stdout": "42\n",
+  "stderr": "",
+  "error": ""
+}
+```
+
+### Read from stdin
+##### Input
+```javascript
+{
+  "language": "python",
+  "stdin": "42",
+  "files": [
+    {
+      "name": "main.py",
+      "content": "print(input('Number from stdin: '))"
+    }
+  ]
+}
+```
+
+##### Output
+```javascript
+{
+  "stdout": "Number from stdin: 42\n",
+  "stderr": "",
+  "error": ""
+}
+```
+
+### Custom run command
+##### Input
+```javascript
+{
+  "language": "bash",
+  "command": "bash main.sh 42",
+  "files": [
+    {
+      "name": "main.sh",
+      "content": "echo Number from arg: $1"
+    }
+  ]
+}
+```
+
+##### Output
+```javascript
+{
+  "stdout": "Number from arg: 42\n",
+  "stderr": "",
+  "error": ""
+}
+```

src/executor.rs

@@ -0,0 +1,48 @@
+use std::io::{Write, Error};
+use std::process::{Command, Stdio};
+use std::result::Result;
+use types::ExecutorResult;
+
+pub fn run_stdin(work_dir: &str, stdin: &str, args: &[&str]) -> Result<ExecutorResult, Error> {
+    let mut command = Command::new(&args[0]);
+    command
+        .args(&args[1..])
+        .current_dir(work_dir)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+
+    let mut child = command
+        .spawn()
+        .expect("Failed to spawn child process");
+
+    {
+        let stdin_stream = child.stdin.as_mut().expect("Failed to open stdin");
+        stdin_stream.write_all(stdin.as_bytes()).expect("Failed to write to stdin");
+    }
+
+    let output = child.wait_with_output().expect("Failed to read stdout");
+
+    let code = match output.status.code() {
+        Some(code) => code,
+        None       => -1
+    };
+
+    Ok(ExecutorResult{
+        stdout: String::from_utf8_lossy(&output.stdout).to_string(),
+        stderr: String::from_utf8_lossy(&output.stderr).to_string(),
+        status_code: code.to_string()
+    })
+}
+
+pub fn run(work_dir: &str, args: &[&str]) -> Result<ExecutorResult, Error>{
+    run_stdin(work_dir, "", &args)
+}
+
+pub fn run_bash_stdin(work_dir: &str, command: &str, stdin: &str) -> Result<ExecutorResult, Error> {
+    run_stdin(work_dir, stdin, &["bash", "-c", command])
+}
+
+/* pub fn run_bash(work_dir: &str, command: &str) -> Result<ExecutorResult, Error> {
+    run(work_dir, &["bash", "-c", command])
+} */

src/languages/golang.rs

@@ -0,0 +1,17 @@
+use std::io::{Error};
+use types::ExecutorResult;
+use std::path::Path;
+use executor;
+
+pub fn run(files: &Vec<String>, stdin: &str) -> Result<ExecutorResult, Error> {
+    let parent = Path::new(&files[0]).parent();
+    
+    match parent {
+        Some(work_dir) => {
+            executor::run_stdin(&work_dir.to_string_lossy(), &stdin, &["go", "run", &files[0]])
+        }
+        None => {
+            panic!("Error finding work dir");
+        }
+    }
+}

src/languages/javascript.rs

@@ -0,0 +1,18 @@
+use std::io::{Error};
+use types::ExecutorResult;
+use std::path::Path;
+use executor;
+
+pub fn run(files: &Vec<String>, stdin: &str) -> Result<ExecutorResult, Error> {
+    let parent = Path::new(&files[0]).parent();
+
+    match parent {
+        Some(work_dir) => {
+            executor::run_stdin(&work_dir.to_string_lossy(), &stdin, &["node", &files[0]])
+        }
+        None => {
+            panic!("Error finding work dir");
+        }
+    }
+    
+}

src/languages/languages.rs

@@ -0,0 +1,21 @@
+use phf::phf_map;
+use std::io::{Error};
+use types::ExecutorResult;
+use languages;
+
+type RunnerFunction = fn(&Vec<String>, &str) -> Result<ExecutorResult, Error>;
+
+static RUNNERS: phf::Map<&'static str, RunnerFunction> = phf_map! {
+    "javascript" => languages::javascript::run,
+    "python" => languages::python::run,
+    "go" => languages::golang::run,
+    "rust" => languages::rust::run,
+};
+
+pub fn is_supported(language: &str) -> bool {
+    RUNNERS.contains_key(language)
+}
+
+pub fn run(language: &str, files: &Vec<String>, stdin: &str) -> Result<ExecutorResult, Error> {
+    RUNNERS[language](files, stdin)
+}

src/languages/mod.rs

@@ -0,0 +1,9 @@
+pub use self::languages::{is_supported, run};
+
+mod languages;
+
+// Language Runners
+mod javascript;
+mod golang;
+mod python;
+mod rust;

src/languages/python.rs

@@ -0,0 +1,17 @@
+use std::io::{Error};
+use types::ExecutorResult;
+use std::path::Path;
+use executor;
+
+pub fn run(files: &Vec<String>, stdin: &str) -> Result<ExecutorResult, Error> {
+    let parent = Path::new(&files[0]).parent();
+    
+    match parent {
+        Some(work_dir) => {
+            executor::run_stdin(&work_dir.to_string_lossy(), &stdin, &["python", &files[0]])
+        }
+        None => {
+            panic!("Error finding work dir");
+        }
+    }
+}

src/languages/rust.rs

@@ -0,0 +1,28 @@
+use std::io::{Error};
+use types::ExecutorResult;
+use std::path::Path;
+use executor;
+
+pub fn run(files: &Vec<String>, stdin: &str) -> Result<ExecutorResult, Error> {
+    let parent = Path::new(&files[0]).parent();
+    let bin_name: String = "a.out".to_string();
+
+    match parent {
+        Some(work_dir) => {
+            let result = executor::run(&work_dir.to_string_lossy(), &["rustc", "-o", &bin_name, &files[0]]);
+
+            match result {
+                Ok(_compiler_result) => {
+                    let path = Path::new(work_dir).join(bin_name);
+                    executor::run_stdin(&work_dir.to_string_lossy(), &stdin, &[&path.as_path().to_string_lossy()])
+                }
+                Err(_e) => {
+                    panic!("Error to execute rust code {:?}", _e)
+                }
+            }
+        }
+        None => {
+            panic!("Error finding work dir");
+        }
+    }
+}

src/main.rs

@@ -0,0 +1,64 @@
+#![feature(proc_macro_hygiene)]
+#[macro_use]
+extern crate serde_derive;
+extern crate serde;
+extern crate serde_json;
+extern crate phf;
+extern crate tempfile;
+
+mod types;
+mod utils;
+mod executor;
+mod languages;
+
+use std::path::Path;
+use std::io::{self, Read};
+use utils::parse_payload;
+use utils::write_files;
+use tempfile::tempdir;
+
+fn main() -> io::Result<()> {
+    let mut buffer = String::new();
+    io::stdin().read_to_string(&mut buffer)?;
+
+    let temp_dir = tempdir()?;
+    let payload = parse_payload(&buffer)?;
+    let filepaths = write_files(&temp_dir, &payload.files)?;
+
+    let executor_result = if payload.command == "" {
+        languages::run(&payload.language, &filepaths, &payload.stdin)
+    } else {
+        let parent = Path::new(&filepaths[0]).parent();
+
+        match parent {
+            Some(work_dir) => {
+                executor::run_bash_stdin(&work_dir.to_string_lossy(), &payload.command, &payload.stdin)
+            }
+            None => {
+                panic!("Error finding work dir");
+            }
+        }
+    };
+
+    let mut result = types::Result::new();
+    
+    match executor_result {
+        Ok(output) => {
+            result.stdout = output.stdout;
+            result.stderr = output.stderr;
+
+            let json = serde_json::to_string(&result)?;
+            println!("{}", json);
+        }
+        Err(_e) => {
+            result.error = format!("{}", _e);
+
+            let json = serde_json::to_string(&result)?;
+            println!("{}", json);
+        }
+    }
+
+    temp_dir.close()?;
+
+    Ok(())
+}