shimkit 0.3.1

Opinionated library for building containerd shims
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Common utilities for the containerd shims.

use std::fs::File;
use std::io::{Error as IoError, ErrorKind, Result as IoResult};
use std::path::PathBuf;

use serde::{Deserialize, Serialize};

use super::{Error, InstanceConfig};
use crate::sys::DEFAULT_CONTAINER_ROOT_DIR;
use crate::sys::stdio::open;

#[derive(Serialize, Deserialize)]
struct Options {
    root: Option<PathBuf>,
}

impl InstanceConfig {
    /// Determine the root directory for the container runtime.
    ///
    /// If the `bundle` directory contains an `options.json` file, the root directory is read from the
    /// file. Otherwise, the root directory is determined by `{DEFAULT_CONTAINER_ROOT_DIR}/{runtime}/{namespace}`.
    ///
    /// The default root directory is `/run/containerd/<wasm engine name>/<namespace>`.
    #[cfg_attr(feature = "tracing", tracing::instrument(level = "Debug"))]
    pub fn determine_rootdir(
        &self,
        runtime: impl AsRef<str> + std::fmt::Debug,
    ) -> Result<PathBuf, Error> {
        let rootdir = DEFAULT_CONTAINER_ROOT_DIR.join(runtime.as_ref());
        let file = match File::open(self.bundle.join("options.json")) {
            Ok(f) => f,
            Err(e) if e.kind() == ErrorKind::NotFound => return Ok(rootdir.join(&self.namespace)),
            Err(e) => return Err(e.into()),
        };
        let path = serde_json::from_reader::<_, Options>(file)?
            .root
            .unwrap_or(rootdir)
            .join(&self.namespace);
        log::info!("container runtime root path is {path:?}");
        Ok(path)
    }

    pub fn open_stdin(&self) -> IoResult<File> {
        if self.stdin.as_os_str().is_empty() {
            return Err(IoError::new(ErrorKind::NotFound, "File not found"));
        }
        open(&self.stdin)
    }

    pub fn open_stdout(&self) -> IoResult<File> {
        if self.stdout.as_os_str().is_empty() {
            return Err(IoError::new(ErrorKind::NotFound, "File not found"));
        }
        open(&self.stdout)
    }

    pub fn open_stderr(&self) -> IoResult<File> {
        if self.stderr.as_os_str().is_empty() {
            return Err(IoError::new(ErrorKind::NotFound, "File not found"));
        }
        open(&self.stderr)
    }
}

#[cfg(unix)]
#[cfg(test)]
mod tests {
    use tempfile::tempdir;

    use super::*;

    #[test]
    fn test_determine_rootdir_with_options_file() -> Result<(), Error> {
        let namespace = "test_namespace";
        let dir = tempdir()?;
        let rootdir = dir.path().join("runwasi");
        let opts = Options {
            root: Some(rootdir.clone()),
        };
        std::fs::write(
            dir.path().join("options.json"),
            serde_json::to_string(&opts)?,
        )?;
        let cfg = InstanceConfig {
            bundle: dir.path().to_path_buf(),
            namespace: namespace.to_string(),
            ..Default::default()
        };
        let root = cfg.determine_rootdir("runtime")?;
        assert_eq!(root, rootdir.join(namespace));
        Ok(())
    }

    #[test]
    fn test_determine_rootdir_without_options_file() -> Result<(), Error> {
        let dir = tempdir()?;
        let namespace = "test_namespace";
        let cfg = InstanceConfig {
            bundle: dir.path().to_path_buf(),
            namespace: namespace.to_string(),
            ..Default::default()
        };
        let root = cfg.determine_rootdir("runtime")?;
        assert!(root.is_absolute());
        assert_eq!(
            root,
            PathBuf::from("/run/containerd/runtime").join(namespace)
        );
        Ok(())
    }
}