fix: Limit only player logs not simulator logs (#28)

Author: dipeshkaphle

src/cpp.rs

@@ -40,7 +40,7 @@ impl Runner {
                 ))
             })?;
 
-        let _ = handle_process(compile, |x| SimulatorError::CompilationError(x))?;
+        let _ = handle_process(compile, true, |x| SimulatorError::CompilationError(x))?;
 
         Command::new("timeout".to_owned())
             .args([

src/java.rs

@@ -44,7 +44,7 @@ impl Runner {
                 ))
             })?;
 
-        let _ = handle_process(compile, |x| SimulatorError::CompilationError(x))?;
+        let _ = handle_process(compile, true, |x| SimulatorError::CompilationError(x))?;
 
         Command::new("timeout".to_owned())
             .args([

src/lib.rs

@@ -15,25 +15,33 @@ pub mod response;
 pub mod simulator;
 pub mod utils;
 
-// maximum size for log will be around 2 MBs, everything after that is ignored
-const MAXLOGSIZE: usize = 2000000;
+// maximum size for log will be around 200KBs, everything after that is ignored
+const MAXLOGSIZE: usize = 200000;
 const SIGKILL: i32 = 9;
 
 pub fn handle_process(
     proc: Child,
+    is_player_process: bool,
     make_err: fn(String) -> SimulatorError,
 ) -> Result<String, SimulatorError> {
     match proc.wait_with_output() {
         Ok(out) => {
-            let mut truncated_logs = out.stderr.take(MAXLOGSIZE as u64);
-            let mut logs = String::new();
-            let logs_extraction_result = truncated_logs.read_to_string(&mut logs);
+            let logs_extraction_result: Result<String, std::io::Error> = if is_player_process {
+                let mut logs = String::new();
+                out.stderr
+                    .take(MAXLOGSIZE as u64)
+                    .read_to_string(&mut logs)
+                    .map(|_| logs)
+            } else {
+                String::from_utf8(out.stderr)
+                    .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, format!("{}", e)))
+            };
             if out.status.success() {
                 match logs_extraction_result {
                     Err(e) => Err(SimulatorError::UnidentifiedError(
                         format!("Error during log extraction: {}", e).to_owned(),
                     )),
-                    Ok(_) => Ok(logs),
+                    Ok(logs) => Ok(logs),
                 }
             } else {
                 if let Some(sig) = out.status.signal() {
@@ -50,7 +58,7 @@ pub fn handle_process(
                         )
                         .to_owned(),
                     )),
-                    Ok(_) => Err(make_err(format!(
+                    Ok(logs) => Err(make_err(format!(
                         "Program exited with non zero exit code: {} ",
                         logs
                     ))),

src/main.rs

@@ -111,15 +111,15 @@ fn handler(game_request: GameRequest) -> GameStatus {
             };
 
             let player_process_out =
-                cc_driver::handle_process(player_pid, |x| SimulatorError::RuntimeError(x));
+                cc_driver::handle_process(player_pid, true, |x| SimulatorError::RuntimeError(x));
             if let Err(err) = player_process_out {
                 error!("Error from player.");
                 return create_error_response(&game_request, err);
             }
             let player_process_out = player_process_out.unwrap();
 
             let sim_process_out =
-                cc_driver::handle_process(sim_pid, |x| SimulatorError::RuntimeError(x));
+                cc_driver::handle_process(sim_pid, false, |x| SimulatorError::RuntimeError(x));
             if let Err(err) = sim_process_out {
                 error!("Error from simulator.");
                 return create_error_response(&game_request, err);