make methods in Local async

Signed-off-by: Jorge Prendes <jorge.prendes@gmail.com>

crates/containerd-shim-wasm/Cargo.toml

@@ -36,6 +36,8 @@ sha256 = { workspace = true }
 serde_bytes = "0.11"
 prost = "0.13"
 toml = "0.8"
+trait-variant = "0.1"
+tokio-async-drop = "0.1"
 
 # tracing
 # note: it's important to keep the version of tracing in sync with tracing-subscriber

crates/containerd-shim-wasm/src/sandbox/instance.rs

@@ -32,28 +32,29 @@ pub struct InstanceConfig {
 /// Instance is a trait that gets implemented by consumers of this library.
 /// This trait requires that any type implementing it is `'static`, similar to `std::any::Any`.
 /// This means that the type cannot contain a non-`'static` reference.
+#[trait_variant::make(Send)]
 pub trait Instance: 'static {
     /// The WASI engine type
     type Engine: Send + Sync + Clone;
 
     /// Create a new instance
-    fn new(id: String, cfg: &InstanceConfig) -> Result<Self, Error>
+    async fn new(id: String, cfg: &InstanceConfig) -> Result<Self, Error>
     where
         Self: Sized;
 
     /// Start the instance
     /// The returned value should be a unique ID (such as a PID) for the instance.
     /// Nothing internally should be using this ID, but it is returned to containerd where a user may want to use it.
-    fn start(&self) -> Result<u32, Error>;
+    async fn start(&self) -> Result<u32, Error>;
 
     /// Send a signal to the instance
-    fn kill(&self, signal: u32) -> Result<(), Error>;
+    async fn kill(&self, signal: u32) -> Result<(), Error>;
 
     /// Delete any reference to the instance
     /// This is called after the instance has exited.
-    fn delete(&self) -> Result<(), Error>;
+    async fn delete(&self) -> Result<(), Error>;
 
     /// Waits for the instance to finish and returns its exit code
     /// This is an async call.
-    fn wait(&self) -> impl Future<Output = (u32, DateTime<Utc>)> + Send;
+    async fn wait(&self) -> (u32, DateTime<Utc>);
 }

crates/containerd-shim-wasm/src/sandbox/shim/cli.rs

@@ -1,25 +1,26 @@
 use std::env::current_dir;
 use std::fmt::Debug;
-use std::sync::Arc;
 
 use chrono::Utc;
 use containerd_shim::error::Error as ShimError;
 use containerd_shim::publisher::RemotePublisher;
 use containerd_shim::util::write_address;
-use containerd_shim::{self as shim, ExitSignal, api};
+use containerd_shim::{self as shim, api};
 use oci_spec::runtime::Spec;
 use shim::Flags;
 
+use crate::sandbox::async_utils::AmbientRuntime as _;
 use crate::sandbox::instance::Instance;
 use crate::sandbox::shim::events::{RemoteEventSender, ToTimestamp};
 use crate::sandbox::shim::local::Local;
+use crate::sandbox::sync::WaitableCell;
 
 /// Cli implements the containerd-shim cli interface using `Local<T>` as the task service.
 pub struct Cli<T: Instance + Sync + Send> {
     engine: T::Engine,
     namespace: String,
     containerd_address: String,
-    exit: Arc<ExitSignal>,
+    exit: WaitableCell<()>,
     _id: String,
 }
 
@@ -50,7 +51,7 @@ where
             engine: Default::default(),
             namespace: args.namespace.to_string(),
             containerd_address: args.address.clone(),
-            exit: Arc::default(),
+            exit: WaitableCell::new(),
             _id: args.id.to_string(),
         }
     }
@@ -78,7 +79,7 @@ where
 
     #[cfg_attr(feature = "tracing", tracing::instrument(level = "Info"))]
     fn wait(&mut self) {
-        self.exit.wait();
+        self.exit.wait().block_on();
     }
 
     #[cfg_attr(

crates/containerd-shim-wasm/src/sandbox/shim/instance_data.rs

@@ -14,9 +14,12 @@ pub(super) struct InstanceData<T: Instance> {
 
 impl<T: Instance> InstanceData<T> {
     #[cfg_attr(feature = "tracing", tracing::instrument(level = "Debug"))]
-    pub fn new(id: impl AsRef<str> + std::fmt::Debug, config: InstanceConfig) -> Result<Self> {
+    pub async fn new(
+        id: impl AsRef<str> + std::fmt::Debug,
+        config: InstanceConfig,
+    ) -> Result<Self> {
         let id = id.as_ref().to_string();
-        let instance = T::new(id, &config)?;
+        let instance = T::new(id, &config).await?;
         Ok(Self {
             instance,
             config,
@@ -31,11 +34,11 @@ impl<T: Instance> InstanceData<T> {
     }
 
     #[cfg_attr(feature = "tracing", tracing::instrument(skip(self), level = "Debug"))]
-    pub fn start(&self) -> Result<u32> {
+    pub async fn start(&self) -> Result<u32> {
         let mut s = self.state.write().unwrap();
         s.start()?;
 
-        let res = self.instance.start();
+        let res = self.instance.start().await;
 
         // These state transitions are always `Ok(())` because
         // we hold the lock since `s.start()`
@@ -51,19 +54,19 @@ impl<T: Instance> InstanceData<T> {
     }
 
     #[cfg_attr(feature = "tracing", tracing::instrument(skip(self), level = "Debug"))]
-    pub fn kill(&self, signal: u32) -> Result<()> {
+    pub async fn kill(&self, signal: u32) -> Result<()> {
         let mut s = self.state.write().unwrap();
         s.kill()?;
 
-        self.instance.kill(signal)
+        self.instance.kill(signal).await
     }
 
     #[cfg_attr(feature = "tracing", tracing::instrument(skip(self), level = "Debug"))]
-    pub fn delete(&self) -> Result<()> {
+    pub async fn delete(&self) -> Result<()> {
         let mut s = self.state.write().unwrap();
         s.delete()?;
 
-        let res = self.instance.delete();
+        let res = self.instance.delete().await;
 
         if res.is_err() {
             // Always `Ok(())` because we hold the lock since `s.delete()`