wip

Author: Brayan-724

backend/runner/src/hakoniwa_ext.rs

@@ -0,0 +1,28 @@
+use hakoniwa::{Child, ExitStatus};
+use nix::sys::wait::{self, WaitPidFlag, WaitStatus};
+
+trait HakoniwaChildExt {
+    fn try_wait(&self) -> Option<ExitStatus>;
+}
+
+impl HakoniwaChildExt for Child {
+    fn try_wait(&self) -> Option<ExitStatus> {
+        match wait::waitpid(self.id(), Some(WaitPidFlag::WNOHANG)) {
+            Ok(WaitStatus::StillAlive) => None,
+            Ok(WaitStatus::Exited(_, code)) => Some(ExitStatus {
+                code,
+                // Mario reference
+                reason: "Life is good".to_owned(),
+                exit_code: None,
+                rusage: None,
+            }),
+            Ok(WaitStatus::Signaled(_, signal, _) | WaitStatus::Stopped(_, signal)) => Some(ExitStatus {
+                code: signal as i32,
+                reason: signal.as_str().to_owned(),
+                exit_code: None,
+                rusage: None,
+            }),
+            Ok(WaitStatus::Continued(_)) => None,
+        }
+    }
+}

backend/runner/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod error;
+pub mod hakoniwa_ext;
 
 use hakoniwa::{Child, Command, Container, ExitStatus, Output};
 use nix::libc::pid_t;
@@ -138,24 +139,37 @@ impl Runner {
         let stderr = tokio::spawn(stderr_fn(stderr));
 
         let child_pid = Pid::from_raw(child.id() as pid_t);
-        let abort_task = tokio::spawn(async move {
-            let Some(abort) = abort else {
-                return;
-            };
-
-            _ = abort.await;
-
-            println!("[[[[KILL]]]]");
-            _ = signal::kill(child_pid, Signal::SIGKILL);
-        });
-
-        let status = tokio::task::spawn_blocking(move || child.wait());
+        let status = if let Some(abort) = abort {
+            tokio::spawn(async move {
+                loop {
+                    tokio::select! {
+                        _ = abort => {
+                            println!("[[[[KILL]]]]");
+                            _ = signal::kill(child_pid, Signal::SIGKILL);
+                            return Ok(ExitStatus {
+                                code: 137,
+                                reason: "Aborted".to_owned(),
+                                exit_code: None,
+                                rusage: None,
+                            });
+                        },
+                        else => {
+                            return Ok(ExitStatus {
+                                code: 137,
+                                reason: "Aborted".to_owned(),
+                                exit_code: None,
+                                rusage: None,
+                            });
+                        }
+                    }
+                }
+            })
+        } else {
+            tokio::task::spawn_blocking(move || child.wait())
+        };
 
         let (status, stdout, stderr) = tokio::join!(status, stdout, stderr);
 
-        // Cancel abort task
-        abort_task.abort();
-
         let status = status
             .inspect_err(|err| eprintln!("Join error: {err}"))
             .map(|o| o.inspect_err(|err| eprintln!("Join error: {err}")).ok())