fix: Cleanup by sending a command and kill when dropped (#1945)

* fix: Cleanup by sending a command and kill when dropped

* chore: Fix the loadModule run command

* fix: cleans up failed health

* refactor long-running

* chore: Fixes?"

* refactor

* run iso ci on pr

* fix debuild

* fix tests

* switch to libc kill

* kill process by parent

* fix graceful shutdown

* recurse submodules

* fix compat build

* feat: Add back in the timeout

* chore: add the missing types for the unnstable

* inherited logs

Co-authored-by: J M <Blu-J@users.noreply.github.com>

* fix deleted code

Co-authored-by: Aiden McClelland <me@drbonez.dev>
Co-authored-by: J M <Blu-J@users.noreply.github.com>

backend/src/procedure/js_scripts.rs

@@ -2,17 +2,20 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
 
+use color_eyre::eyre::eyre;
+use embassy_container_init::{ProcessGroupId, SignalGroup, SignalGroupParams};
+use helpers::RpcClient;
 pub use js_engine::JsError;
 use js_engine::{JsExecutionEnvironment, PathForVolumeId};
-use models::VolumeId;
-use models::{ExecCommand, TermCommand};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use models::{ErrorKind, VolumeId};
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
 use super::ProcedureName;
 use crate::context::RpcContext;
 use crate::s9pk::manifest::PackageId;
-use crate::util::Version;
+use crate::util::{GeneralGuard, Version};
 use crate::volume::Volumes;
 use crate::Error;
 
@@ -42,7 +45,7 @@ impl PathForVolumeId for Volumes {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct JsProcedure {
     #[serde(default)]
@@ -54,7 +57,7 @@ impl JsProcedure {
         Ok(())
     }
 
-    #[instrument(skip(directory, input, exec_command, term_command))]
+    #[instrument(skip(directory, input, rpc_client))]
     pub async fn execute<I: Serialize, O: DeserializeOwned>(
         &self,
         directory: &PathBuf,
@@ -64,17 +67,32 @@ impl JsProcedure {
         volumes: &Volumes,
         input: Option<I>,
         timeout: Option<Duration>,
-        exec_command: ExecCommand,
-        term_command: TermCommand,
+        gid: ProcessGroupId,
+        rpc_client: Option<Arc<RpcClient>>,
     ) -> Result<Result<O, (i32, String)>, Error> {
-        Ok(async move {
+        let cleaner_client = rpc_client.clone();
+        let cleaner = GeneralGuard::new(move || {
+            tokio::spawn(async move {
+                if let Some(client) = cleaner_client {
+                    client
+                        .request(SignalGroup, SignalGroupParams { gid, signal: 9 })
+                        .await
+                        .map_err(|e| {
+                            Error::new(eyre!("{}: {:?}", e.message, e.data), ErrorKind::Docker)
+                        })
+                } else {
+                    Ok(())
+                }
+            })
+        });
+        let res = async move {
             let running_action = JsExecutionEnvironment::load_from_package(
                 directory,
                 pkg_id,
                 pkg_version,
                 Box::new(volumes.clone()),
-                exec_command,
-                term_command,
+                gid,
+                rpc_client,
             )
             .await?
             .run_action(name, input, self.args.clone());
@@ -88,7 +106,9 @@ impl JsProcedure {
             Ok(output)
         }
         .await
-        .map_err(|(error, message)| (error.as_code_num(), message)))
+        .map_err(|(error, message)| (error.as_code_num(), message));
+        cleaner.drop().await.unwrap()?;
+        Ok(res)
     }
 
     #[instrument(skip(ctx, input))]
@@ -108,12 +128,8 @@ impl JsProcedure {
                 pkg_id,
                 pkg_version,
                 Box::new(volumes.clone()),
-                Arc::new(|_, _, _, _| {
-                    Box::pin(async { Err("Can't run commands in sandox mode".to_string()) })
-                }),
-                Arc::new(|_| {
-                    Box::pin(async move { Err("Can't run commands in test".to_string()) })
-                }),
+                ProcessGroupId(0),
+                None,
             )
             .await?
             .read_only_effects()
@@ -193,10 +209,8 @@ async fn js_action_execute() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap()
@@ -252,10 +266,8 @@ async fn js_action_execute_error() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap();
@@ -300,10 +312,8 @@ async fn js_action_fetch() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap()
@@ -341,23 +351,18 @@ async fn js_test_slow() {
     let timeout = Some(Duration::from_secs(10));
     tracing::debug!("testing start");
     tokio::select! {
-     a = js_action
-        .execute::<serde_json::Value, serde_json::Value>(
-            &path,
-            &package_id,
-            &package_version,
-            name,
-            &volumes,
-            input,
-            timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
-        )
-         => {a
-        .unwrap()
-        .unwrap();},
+        a = js_action
+            .execute::<serde_json::Value, serde_json::Value>(
+                &path,
+                &package_id,
+                &package_version,
+                name,
+                &volumes,
+                input,
+                timeout,
+                ProcessGroupId(0),
+                None,
+            ) => { a.unwrap().unwrap(); },
         _ = tokio::time::sleep(Duration::from_secs(1)) => ()
     }
     tracing::debug!("testing end should");
@@ -404,10 +409,8 @@ async fn js_action_var_arg() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap()
@@ -452,10 +455,8 @@ async fn js_action_test_rename() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap()
@@ -500,10 +501,8 @@ async fn js_action_test_deep_dir() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap()
@@ -547,10 +546,8 @@ async fn js_action_test_deep_dir_escape() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap()
@@ -595,10 +592,8 @@ async fn js_rsync() {
             &volumes,
             input,
             timeout,
-            Arc::new(|_, _, _, _| {
-                Box::pin(async move { Err("Can't run commands in test".to_string()) })
-            }),
-            Arc::new(|_| Box::pin(async move { Err("Can't run commands in test".to_string()) })),
+            ProcessGroupId(0),
+            None,
         )
         .await
         .unwrap()