Use youki's libcontainer APIs to implement wasmtime shim.

Cargo.toml

@@ -6,6 +6,7 @@ members = [
     "crates/containerd-shim-wasmedge",
     "crates/containerd-shim-wasmtime",
     "benches/containerd-shim-benchmarks",
+    "crates/common",
 ]
 
 [workspace.package]
@@ -18,6 +19,8 @@ homepage = "https://github.com/containerd/runwasi"
 
 [workspace.dependencies]
 anyhow = "1.0"
+containerd-shim-common = { path = "crates/common" }
+containerd-shim-wasm = { path = "crates/containerd-shim-wasm" }
 serde = "1.0"
 serde_json = "1.0"
 env_logger = "0.10"

crates/common/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "containerd-shim-common"
+version.workspace = true
+edition.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1"
+containerd-shim-wasm = { workspace = true }
+libcontainer = { workspace = true }

crates/common/src/lib.rs

@@ -0,0 +1,55 @@
+//! Common utilities for the containerd shims, including wasmtime and wasmedge shim.
+
+use anyhow::{bail, Context, Result};
+use containerd_shim_wasm::sandbox::error::Error;
+use libcontainer::container::Container;
+use std::{
+    fs::{self, OpenOptions},
+    io::ErrorKind,
+    os::fd::{IntoRawFd, RawFd},
+    path::{Path, PathBuf},
+};
+
+/// Loads the container state from the given root path.
+pub fn load_container<P: AsRef<Path>>(root_path: P, container_id: &str) -> Result<Container> {
+    let container_root = construct_container_root(root_path, container_id)?;
+    if !container_root.exists() {
+        bail!("container {} does not exist.", container_id)
+    }
+
+    Container::load(container_root)
+        .with_context(|| format!("could not load state for container {container_id}"))
+}
+
+/// Checks if the container exists.
+pub fn container_exists<P: AsRef<Path>>(root_path: P, container_id: &str) -> Result<bool> {
+    let container_root = construct_container_root(root_path, container_id)?;
+    Ok(container_root.exists())
+}
+
+/// containerd can send an empty path or a non-existant path
+/// In both these cases we should just assume that the stdio stream was not setup (intentionally)
+/// Any other error is a real error.
+pub fn maybe_open_stdio(path: &str) -> Result<Option<RawFd>, Error> {
+    if path.is_empty() {
+        return Ok(None);
+    }
+    match OpenOptions::new().read(true).write(true).open(path) {
+        Ok(f) => Ok(Some(f.into_raw_fd())),
+        Err(err) => match err.kind() {
+            ErrorKind::NotFound => Ok(None),
+            _ => Err(err.into()),
+        },
+    }
+}
+
+fn construct_container_root<P: AsRef<Path>>(root_path: P, container_id: &str) -> Result<PathBuf> {
+    let root_path = fs::canonicalize(&root_path).with_context(|| {
+        format!(
+            "failed to canonicalize {} for container {}",
+            root_path.as_ref().display(),
+            container_id
+        )
+    })?;
+    Ok(root_path.join(container_id))
+}

crates/containerd-shim-wasmedge/Cargo.toml

@@ -4,8 +4,9 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-containerd-shim ={ workspace = true }
-containerd-shim-wasm = { path = "../containerd-shim-wasm" }
+containerd-shim = { workspace = true }
+containerd-shim-wasm = { workspace = true }
+containerd-shim-common = { workspace = true }
 log = { workspace = true }
 ttrpc = { workspace = true }
 wasmedge-sdk = "0.8.1"

crates/containerd-shim-wasmedge/src/executor.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use containerd_shim_wasm::sandbox::oci;
 use nix::unistd::{dup, dup2};
 use oci_spec::runtime::Spec;
 
@@ -22,7 +23,7 @@ pub struct WasmEdgeExecutor {
 impl Executor for WasmEdgeExecutor {
     fn exec(&self, spec: &Spec) -> Result<(), ExecutorError> {
         // parse wasi parameters
-        let args = get_args(spec);
+        let args = oci::get_args(spec);
         if args.is_empty() {
             return Err(ExecutorError::InvalidArg);
         }
@@ -91,18 +92,6 @@ impl Executor for WasmEdgeExecutor {
     }
 }
 
-fn get_args(spec: &Spec) -> &[String] {
-    let p = match spec.process() {
-        None => return &[],
-        Some(p) => p,
-    };
-
-    match p.args() {
-        None => &[],
-        Some(args) => args.as_slice(),
-    }
-}
-
 fn env_to_wasi(spec: &Spec) -> Vec<String> {
     let default = vec![];
     let env = spec