feat: capture AI stderr and return it to the client

Author: Thechi2000

backend/README.md

@@ -95,6 +95,7 @@ Errors are returned as status code. Most notable ones are:
 interface GameState {
   board: Board;
   current_player: Player;
+  ai_output: string; // Everything printed by the AI on stderr since the start/last move.
 }
 
 type Board = (Piece | null)[][];

backend/src/api/play.rs

@@ -1,6 +1,6 @@
 use super::{AppState, Error, User};
 use crate::game::{GameState, Move, Player};
-use async_process::{Child, ChildStdin, ChildStdout};
+use async_process::{Child, ChildStderr, ChildStdin, ChildStdout};
 use rocket::{
     futures::{io::BufReader, AsyncBufReadExt, AsyncWriteExt},
     get, post,
@@ -14,6 +14,7 @@ pub struct Game {
     handle: Child,
     stdin: ChildStdin,
     stdout: BufReader<ChildStdout>,
+    stderr: BufReader<ChildStderr>,
     checkers: GameState,
     human_player: Player,
 }
@@ -72,24 +73,40 @@ pub async fn start(
     user: User,
     is_first_player: bool,
 ) -> Result<Json<GameState>, Error> {
-    let mut lock = state.lock().unwrap();
+    let game = {
+        let lock = state.lock().unwrap();
+        lock.games.get(&user.name).cloned()
+    };
 
-    if lock.games.contains_key(&user.name) {
-        return Err(Error::GameAlreadyInProgress);
+    if let Some(game) = game {
+        if game.lock().await.handle.try_status()?.is_none() {
+            return Err(Error::GameAlreadyInProgress);
+        }
     }
 
-    let mut child = lock
-        .submissions
-        .get(&user.name)
-        .ok_or(Error::NotFound)?
-        .start()?;
-    let checkers: GameState = Default::default();
+    let mut child = {
+        let lock = state.lock().unwrap();
+        lock.submissions
+            .get(&user.name)
+            .ok_or(Error::NotFound)?
+            .start()?
+    };
+    let mut checkers: GameState = Default::default();
 
+    let mut stderr = BufReader::new(child.stderr.take().unwrap());
+
+    let mut output = vec![];
+    stderr.read_until(1, &mut output).await?;
+
+    checkers.ai_output = String::from_utf8_lossy(&output).to_string();
+
+    let mut lock = state.lock().unwrap();
     lock.games.insert(
         user.name,
         Arc::new(Mutex::new(Game {
             stdin: child.stdin.take().unwrap(),
             stdout: BufReader::new(child.stdout.take().unwrap()),
+            stderr,
             handle: child,
             human_player: if is_first_player {
                 Player::White

backend/src/api/submissions.rs

@@ -51,23 +51,28 @@ impl Submission {
     }
 
     pub fn start(&self) -> Result<Child, Error> {
-        match self.lang {
-            Language::Python => Command::new("docker")
-                .args([
-                    "run",
-                    "-v",
-                    format!("{}:/script.py", self.code.to_string_lossy()).as_str(),
-                    "-i",
-                    "python:3-bullseye",
-                    "python",
-                    "/script.py",
-                ])
-                .stdin(Stdio::piped())
-                .stdout(Stdio::piped())
-                .spawn()
-                .map_err(Error::from),
-            _ => todo!(),
-        }
+        let (image, command) = match self.lang {
+            Language::Cpp => ("ghcr.io/clicepfl/s4s-2024-cpp:main", "cp /script /script.cpp && g++ /script.cpp -o /exe && /exe"),
+            Language::Java => ("cimg/openjdk:17.0", "java /script"),
+            Language::Python => ("python:3-bullseye", "python /script"),
+        };
+
+        Command::new("docker")
+            .args([
+                "run",
+                "-v",
+                format!("{}:/script", self.code.to_string_lossy()).as_str(),
+                "-i",
+                image,
+                "sh",
+                "-c",
+                command,
+            ])
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(Error::from)
     }
 }
 

backend/src/game.rs

@@ -83,13 +83,15 @@ fn default_board() -> Board {
 pub struct GameState {
     pub board: Board,
     pub current_player: Player,
+    pub ai_output: String,
 }
 
 impl Default for GameState {
     fn default() -> Self {
         Self {
             board: default_board(),
             current_player: Player::White,
+            ai_output: Default::default(),
         }
     }
 }
@@ -383,7 +385,7 @@ impl GameState {
 
 #[cfg(test)]
 mod test {
-    use super::{Board, GameState, Move, MoveSequence, Piece, Position};
+    use super::{Board, GameState, Move, MoveSequence, Piece};
     use core::hash::Hash;
     use std::collections::HashSet;
 
@@ -414,11 +416,13 @@ mod test {
             GameState {
                 board: board.clone(),
                 current_player: crate::game::Player::White,
+                ..Default::default()
             }
             .list_valid_moves(),
             GameState {
                 board,
                 current_player: crate::game::Player::Black,
+                ..Default::default()
             }
             .list_valid_moves(),
         )
@@ -448,6 +452,7 @@ mod test {
                 [None, None, None, None, None, None, None, None, None, None],
             ],
             current_player: super::Player::White,
+            ..Default::default()
         };
         assert!(state.list_valid_moves().is_empty());
     }