refactor: move config vars to env (#5)

* refactor: move config vars to env

* fix: build workflow

Author: vigneshd332

.github/workflows/rust.yml

@@ -22,6 +22,8 @@ jobs:
         with:
           toolchain: nightly
           override: true
+      - name: Copy config
+        run: cp config.example.toml config.toml
       - name: Build
         run: cargo build --verbose
       - name: Run tests

.gitignore

@@ -3,3 +3,4 @@ Cargo.lock
 *.o
 driver.log
 codecharacter-driver-2022
+config.toml

README.md

@@ -3,6 +3,7 @@
 1. Install [Rust](https://www.rust-lang.org/tools/install)
 
 2. Switch to Rust Nightly
+
    ```
    rustup install nightly && rustup default nightly
    ```
@@ -25,7 +26,11 @@
     git submodule update --init
    ```
 
-3. Run
+3. Create config files
+   ```
+   cp config.example.toml config.toml
+   ```
+4. Run
    ```
    cargo run
    ```

config.example.toml

@@ -0,0 +1,18 @@
+[env]
+SIMULATOR_IMAGE=ghcr.io/delta/codecharacter-simulator:latest
+CPP_COMPILER_IMAGE=ghcr.io/delta/codecharacter-cpp-compiler:latest
+CPP_RUNNER_IMAGE=ghcr.io/delta/codecharacter-cpp-runner:latest
+JAVA_COMPILER_IMAGE=ghcr.io/delta/codecharacter-java-compiler:latest
+JAVA_RUNNER_IMAGE=ghcr.io/delta/codecharacter-java-runner:latest
+PYTHON_RUNNER_IMAGE=ghcr.io/delta/codecharacter-python-runner:latest
+
+MAX_LOG_SIZE=200000
+COMPILATION_TIME_LIMIT=5
+RUNTIME_TIME_LIMIT=10
+COMPILATION_MEMORY_LIMIT=300m
+RUNTIME_MEMORY_LIMIT=100m
+EPOLL_WAIT_TIMEOUT=30_000
+
+RABBITMQ_HOST=amqp://guest:guest@localhost
+REQUEST_QUEUE=gameRequestQueue
+RESPONSE_QUEUE=gameStatusUpdateQueue

src/lib.rs

@@ -14,14 +14,6 @@ pub mod response;
 pub mod runner;
 pub mod utils;
 
-// maximum size for log will be around 200KBs, everything after that is ignored
-const MAXLOGSIZE: usize = 200000;
-const COMPILATION_TIME_LIMIT: &str = "5";
-const RUNTIME_TIME_LIMIT: &str = "10";
-const COMPILATION_MEMORY_LIMIT: &str = "300m";
-const RUNTIME_MEMORY_LIMIT: &str = "100m";
-pub const EPOLL_WAIT_TIMEOUT: isize = 30_000;
-
 fn get_turnwise_logs(player_log: String) -> HashMap<usize, Vec<String>> {
     let mut turnwise_logs = HashMap::new();
 

src/main.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+use std::env;
 
 use cc_driver::{
     create_error_response, create_executing_response,
@@ -12,8 +13,7 @@ use cc_driver::{
     },
     request::{GameRequest, Language},
     response::GameStatus,
-    runner::{cpp, java, py, simulator, Runnable},
-    EPOLL_WAIT_TIMEOUT,
+    runner::{cpp, java, py, simulator, Runnable}
 };
 use log::{info, LevelFilter};
 use log4rs::{
@@ -29,7 +29,7 @@ use nix::sys::epoll::EpollFlags;
 fn handle_event(
     epoll_handle: &mut EpollGeneric<EpollEntryType>,
 ) -> Result<Vec<Option<ProcessOutput>>, SimulatorError> {
-    let events = epoll_handle.poll(EPOLL_WAIT_TIMEOUT, epoll_handle.get_registered_fds().len())?;
+    let events = epoll_handle.poll(env::var("EPOLL_WAIT_TIMEOUT").unwrap().parse().unwrap(), epoll_handle.get_registered_fds().len())?;
     let mut res = vec![];
     for e in events {
         match epoll_handle.process_event(e)? {

src/poll/epoll_entry.rs

@@ -1,12 +1,12 @@
 use nix::sys::epoll::EpollFlags;
 
 use crate::error::EpollError;
-use crate::MAXLOGSIZE;
 
 use std::io::Read;
 use std::os::fd::AsRawFd;
 use std::os::linux::process::ChildExt;
 use std::process::ChildStderr;
+use std::env;
 
 use crate::error::SimulatorError;
 
@@ -90,7 +90,10 @@ impl ProcessOutput {
 
         match self.process_type {
             ProcessType::Runner => {
-                let limit = MAXLOGSIZE;
+                let limit: usize = env::var("MAX_LOG_SIZE")
+                    .unwrap()
+                    .parse()
+                    .unwrap();
                 let stderr = &mut self.stderr;
 
                 let _ = stderr

src/runner/cpp.rs

@@ -2,11 +2,11 @@ use std::{
     fs::File,
     os::linux::process::CommandExt,
     process::{Child, Command, Stdio},
+    env,
 };
 
 use crate::{
-    error::SimulatorError, COMPILATION_MEMORY_LIMIT, COMPILATION_TIME_LIMIT, RUNTIME_MEMORY_LIMIT,
-    RUNTIME_TIME_LIMIT,
+    error::SimulatorError
 };
 
 use super::Runnable;
@@ -30,11 +30,11 @@ impl Runnable for Runner {
         let compile = Command::new("docker")
             .args([
                 "run",
-                &format!("--memory={COMPILATION_MEMORY_LIMIT}"),
-                &format!("--memory-swap={COMPILATION_MEMORY_LIMIT}"),
+                &format!("--memory={}", env::var("COMPILATION_MEMORY_LIMIT").unwrap()),
+                &format!("--memory-swap={}", env::var("COMPILATION_MEMORY_LIMIT").unwrap()),
                 "--cpus=2",
                 "--ulimit",
-                &format!("cpu={COMPILATION_TIME_LIMIT}:{COMPILATION_TIME_LIMIT}"),
+                &format!("cpu={}:{}", env::var("COMPILATION_TIME_LIMIT").unwrap(), env::var("COMPILATION_TIME_LIMIT").unwrap()),
                 "--rm",
                 "--name",
                 &format!("{}_cpp_compiler", self.game_id),
@@ -68,11 +68,11 @@ impl Runnable for Runner {
         Command::new("docker")
             .args([
                 "run",
-                &format!("--memory={RUNTIME_MEMORY_LIMIT}"),
-                &format!("--memory-swap={RUNTIME_MEMORY_LIMIT}"),
+                &format!("--memory={}", env::var("RUNTIME_MEMORY_LIMIT").unwrap()),
+                &format!("--memory-swap={}", env::var("RUNTIME_MEMORY_LIMIT").unwrap()),
                 "--cpus=1",
                 "--ulimit",
-                &format!("cpu={RUNTIME_TIME_LIMIT}:{RUNTIME_TIME_LIMIT}"),
+                &format!("cpu={}:{}", env::var("RUNTIME_TIME_LIMIT").unwrap(), env::var("RUNTIME_TIME_LIMIT").unwrap()),
                 "--rm",
                 "--name",
                 &format!("{}_cpp_runner", self.game_id),

src/runner/java.rs

@@ -2,11 +2,11 @@ use std::{
     fs::File,
     os::linux::process::CommandExt,
     process::{Child, Command, Stdio},
+    env
 };
 
 use crate::{
-    error::SimulatorError, COMPILATION_MEMORY_LIMIT, COMPILATION_TIME_LIMIT, RUNTIME_MEMORY_LIMIT,
-    RUNTIME_TIME_LIMIT,
+    error::SimulatorError
 };
 
 use super::Runnable;
@@ -30,11 +30,11 @@ impl Runnable for Runner {
         let compile = Command::new("docker")
             .args([
                 "run",
-                &format!("--memory={COMPILATION_MEMORY_LIMIT}"),
-                &format!("--memory-swap={COMPILATION_MEMORY_LIMIT}"),
+                &format!("--memory={}", env::var("COMPILATION_MEMORY_LIMIT").unwrap()),
+                &format!("--memory-swap={}", env::var("COMPILATION_MEMORY_LIMIT").unwrap()),
                 "--cpus=1.5",
                 "--ulimit",
-                &format!("cpu={COMPILATION_TIME_LIMIT}:{COMPILATION_TIME_LIMIT}"),
+                &format!("cpu={}:{}", env::var("COMPILATION_TIME_LIMIT").unwrap(), env::var("COMPILATION_TIME_LIMIT").unwrap()),
                 "--rm",
                 "--name",
                 &format!("{}_java_compiler", self.game_id),
@@ -72,11 +72,11 @@ impl Runnable for Runner {
         Command::new("docker")
             .args([
                 "run",
-                &format!("--memory={RUNTIME_MEMORY_LIMIT}"),
-                &format!("--memory-swap={RUNTIME_MEMORY_LIMIT}"),
+                &format!("--memory={}", env::var("RUNTIME_MEMORY_LIMIT").unwrap()),
+                &format!("--memory-swap={}", env::var("RUNTIME_MEMORY_LIMIT").unwrap()),
                 "--cpus=1",
                 "--ulimit",
-                &format!("cpu={RUNTIME_TIME_LIMIT}:{RUNTIME_TIME_LIMIT}"),
+                &format!("cpu={}:{}", env::var("RUNTIME_TIME_LIMIT").unwrap(), env::var("RUNTIME_TIME_LIMIT").unwrap()),
                 "--rm",
                 "--name",
                 &format!("{}_java_runner", self.game_id),

src/runner/py.rs

@@ -2,9 +2,10 @@ use std::{
     fs::File,
     os::linux::process::CommandExt,
     process::{Command, Stdio},
+    env
 };
 
-use crate::{error::SimulatorError, RUNTIME_MEMORY_LIMIT, RUNTIME_TIME_LIMIT};
+use crate::{error::SimulatorError};
 
 use super::Runnable;
 
@@ -27,11 +28,11 @@ impl Runnable for Runner {
         Command::new("docker")
             .args([
                 "run",
-                &format!("--memory={RUNTIME_MEMORY_LIMIT}"),
-                &format!("--memory-swap={RUNTIME_MEMORY_LIMIT}"),
+                &format!("--memory={}", env::var("RUNTIME_MEMORY_LIMIT").unwrap()),
+                &format!("--memory-swap={}", env::var("RUNTIME_MEMORY_LIMIT").unwrap()),
                 "--cpus=1",
                 "--ulimit",
-                &format!("cpu={RUNTIME_TIME_LIMIT}:{RUNTIME_TIME_LIMIT}"),
+                &format!("cpu={}:{}", env::var("RUNTIME_TIME_LIMIT").unwrap(), env::var("RUNTIME_TIME_LIMIT").unwrap()),
                 "--rm",
                 "--name",
                 &format!("{}_python_runner", self.game_id),