libcontainer 0.6.0

Library for container control
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use nix::sys::wait;
use serde::{Deserialize, Serialize};

// Normally, error types are not implemented as serialize/deserialize, but to
// pass the error from the child process to the parent process, we need to
// implement an error type that can be serialized and deserialized.
#[derive(Debug, Serialize, Deserialize)]
struct ErrorEnclosure {
    source: Option<Box<ErrorEnclosure>>,
    description: String,
}

impl ErrorEnclosure {
    pub fn new<T>(e: &T) -> ErrorEnclosure
    where
        T: ?Sized + std::error::Error,
    {
        ErrorEnclosure {
            description: e.to_string(),
            source: e.source().map(|s| Box::new(ErrorEnclosure::new(s))),
        }
    }
}

impl std::fmt::Display for ErrorEnclosure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.description)
    }
}

impl std::error::Error for ErrorEnclosure {
    fn source(&self) -> Option<&(dyn 'static + std::error::Error)> {
        self.source
            .as_ref()
            .map(|source| &**source as &(dyn 'static + std::error::Error))
    }

    fn description(&self) -> &str {
        &self.description
    }
}

type ClosureResult = Result<(), ErrorEnclosure>;

#[derive(Debug, thiserror::Error)]
pub enum TestError {
    #[error("failed to create channel")]
    Channel(#[from] crate::channel::ChannelError),
    #[error("failed to fork")]
    Fork(#[source] nix::Error),
    #[error("failed to wait for child process")]
    Wait(#[source] nix::Error),
    #[error("failed to run function in child process")]
    Execution(#[source] Box<dyn std::error::Error + Send + Sync>),
    #[error("the closure caused the child process to panic")]
    Panic,
}

#[derive(Debug, thiserror::Error)]
pub enum TestCallbackError {
    #[error("{0}")]
    Custom(String),
    #[error("{0:?}")]
    Other(#[from] Box<dyn std::error::Error + Send + Sync>),
}

impl From<&str> for TestCallbackError {
    fn from(s: &str) -> Self {
        TestCallbackError::Custom(s.to_string())
    }
}

impl From<String> for TestCallbackError {
    fn from(s: String) -> Self {
        TestCallbackError::Custom(s)
    }
}

pub fn test_in_child_process<F>(cb: F) -> Result<(), TestError>
where
    F: FnOnce() -> Result<(), TestCallbackError> + std::panic::UnwindSafe,
{
    let (mut sender, mut receiver) = crate::channel::channel::<ClosureResult>()?;
    match unsafe { nix::unistd::fork().map_err(TestError::Fork)? } {
        nix::unistd::ForkResult::Parent { child } => {
            // Close unused senders
            sender.close().map_err(TestError::Channel)?;
            let res = receiver.recv().map_err(TestError::Channel)?;
            wait::waitpid(child, None).map_err(TestError::Wait)?;
            res.map_err(|err| TestError::Execution(Box::new(err)))?;
        }
        nix::unistd::ForkResult::Child => {
            // Close unused receiver in the child
            receiver.close().map_err(TestError::Channel)?;
            let test_result = match std::panic::catch_unwind(cb) {
                Ok(ret) => ret.map_err(|err| ErrorEnclosure::new(&err)),
                Err(_) => Err(ErrorEnclosure::new(&TestError::Panic)),
            };

            // If we can't send the error to the parent process, there is
            // nothing we can do other than exit properly.
            let _ = sender.send(test_result);
            std::process::exit(0);
        }
    };

    Ok(())
}

#[cfg(test)]
mod tests {
    use core::panic;

    use anyhow::{Result, bail};

    use super::*;

    #[test]
    fn test_child_process() -> Result<()> {
        if test_in_child_process(|| Err(TestCallbackError::Custom("test error".to_string())))
            .is_ok()
        {
            bail!("expecting the child process to return an error")
        }

        Ok(())
    }

    #[test]
    fn test_panic_child_process() -> Result<()> {
        let ret = test_in_child_process(|| {
            panic!("test panic");
        });
        if ret.is_ok() {
            bail!("expecting the child process to panic")
        }

        Ok(())
    }
}