runtime-rs: add the wait and status method for sandbox api

Add the sandbox wait and sandbox status method for sandbox
api.

Signed-off-by: Fupan Li <fupan.lfp@antgroup.com>

src/runtime-rs/crates/runtimes/common/src/sandbox.rs

@@ -4,7 +4,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-use crate::{types::ContainerProcess, ContainerManager};
+use crate::{
+    types::{ContainerProcess, SandboxExitInfo, SandboxStatus},
+    ContainerManager,
+};
 
 use anyhow::Result;
 use async_trait::async_trait;
@@ -31,6 +34,8 @@ pub trait Sandbox: Send + Sync {
     async fn stop(&self) -> Result<()>;
     async fn cleanup(&self) -> Result<()>;
     async fn shutdown(&self) -> Result<()>;
+    async fn status(&self) -> Result<SandboxStatus>;
+    async fn wait(&self) -> Result<SandboxExitInfo>;
 
     // utils
     async fn set_iptables(&self, is_ipv6: bool, data: Vec<u8>) -> Result<Vec<u8>>;

src/runtime-rs/crates/runtimes/src/manager.rs

@@ -9,7 +9,7 @@ use common::{
     message::Message,
     types::{
         ContainerProcess, PlatformInfo, SandboxConfig, SandboxRequest, SandboxResponse,
-        StartSandboxInfo, TaskRequest, TaskResponse,
+        SandboxStatusInfo, StartSandboxInfo, TaskRequest, TaskResponse,
     },
     RuntimeHandler, RuntimeInstance, Sandbox, SandboxNetworkEnv,
 };
@@ -487,10 +487,20 @@ impl RuntimeHandlerManager {
                 Ok(SandboxResponse::StopSandbox)
             }
             SandboxRequest::WaitSandbox(_) => {
-                unimplemented!()
+                let exit_info = sandbox.wait().await.context("wait sandbox")?;
+
+                Ok(SandboxResponse::WaitSandbox(exit_info))
             }
             SandboxRequest::SandboxStatus(_) => {
-                unimplemented!()
+                let status = sandbox.status().await?;
+
+                Ok(SandboxResponse::SandboxStatus(SandboxStatusInfo {
+                    sandbox_id: status.sandbox_id,
+                    pid: status.pid,
+                    state: status.state,
+                    created_at: None,
+                    exited_at: None,
+                }))
             }
             SandboxRequest::Ping(_) => Ok(SandboxResponse::Ping),
             SandboxRequest::ShutdownSandbox(_) => {

src/runtime-rs/crates/runtimes/virt_container/Cargo.toml

@@ -37,6 +37,7 @@ runtime-spec = { path = "../../../../libs/runtime-spec" }
 oci-spec = { version = "0.6.8", features = ["runtime"] }
 persist = { path = "../../persist"}
 resource = { path = "../../resource" }
+strum = { version = "0.24.0", features = ["derive"] }
 
 [features]
 default = ["cloud-hypervisor"]

src/runtime-rs/crates/runtimes/virt_container/src/sandbox.rs

@@ -14,7 +14,11 @@ use async_trait::async_trait;
 use common::message::{Action, Message};
 use common::types::utils::option_system_time_into;
 use common::types::ContainerProcess;
-use common::{types::SandboxConfig, ContainerManager, Sandbox, SandboxNetworkEnv};
+use common::{
+    types::{SandboxConfig, SandboxExitInfo, SandboxStatus},
+    ContainerManager, Sandbox, SandboxNetworkEnv,
+};
+
 use containerd_shim_protos::events::task::{TaskExit, TaskOOM};
 use hypervisor::VsockConfig;
 #[cfg(not(target_arch = "s390x"))]
@@ -38,6 +42,7 @@ use resource::network::{dan_config_path, DanNetworkConfig, NetworkConfig, Networ
 use resource::{ResourceConfig, ResourceManager};
 use runtime_spec as spec;
 use std::sync::Arc;
+use strum::Display;
 use tokio::sync::{mpsc::Sender, Mutex, RwLock};
 use tracing::instrument;
 
@@ -51,7 +56,7 @@ pub struct SandboxRestoreArgs {
     pub sender: Sender<Message>,
 }
 
-#[derive(Clone, Copy, PartialEq, Debug)]
+#[derive(Clone, Copy, PartialEq, Debug, Display)]
 pub enum SandboxState {
     Init,
     Running,
@@ -485,6 +490,28 @@ impl Sandbox for VirtSandbox {
         Ok(())
     }
 
+    async fn status(&self) -> Result<SandboxStatus> {
+        info!(sl!(), "get sandbox status");
+        let inner = self.inner.read().await;
+        let state = inner.state.to_string();
+
+        Ok(SandboxStatus {
+            sandbox_id: self.sid.clone(),
+            pid: std::process::id(),
+            state,
+            ..Default::default()
+        })
+    }
+
+    async fn wait(&self) -> Result<SandboxExitInfo> {
+        info!(sl!(), "wait sandbox");
+        let exit_code = self.hypervisor.wait_vm().await.context("wait vm")?;
+        Ok(SandboxExitInfo {
+            exit_status: exit_code as u32,
+            exited_at: Some(std::time::SystemTime::now()),
+        })
+    }
+
     async fn stop(&self) -> Result<()> {
         let mut sandbox_inner = self.inner.write().await;