1 · Spec e erros#

    /// Fail-closed: recusa o que não sabemos cumprir.
    pub fn validate(&self) -> Result<()> {
        if !self.oci_version.starts_with("1.") {
            return Err(Error::Spec(format!("ociVersion {:?} is not 1.x", self.oci_version)));
        }
        if self.process.args.is_empty() {
            return Err(Error::Spec("process.args must not be empty".into()));
        }
        if !self.process.cwd.starts_with('/') {
            return Err(Error::Spec("process.cwd must be absolute".into()));
        }
        if self.process.terminal {
            return Err(Error::Unsupported("process.terminal=true (no pty support)".into()));
        }
        if self.linux.seccomp.is_some() {
            return Err(Error::Unsupported("linux.seccomp (no filter support)".into()));
        }
        for ns in &self.linux.namespaces {
            if ns.path.is_some() {
                return Err(Error::Unsupported(format!(
                    "linux.namespaces[{}].path (joining an existing namespace)",
                    ns.kind
                )));
            }
        }
        if !self.linux.namespaces.is_empty() {
            for needed in ALWAYS_ISOLATED {
                if !self.linux.namespaces.iter().any(|n| n.kind == needed) {
                    return Err(Error::Unsupported(format!(
                        "linux.namespaces without {needed:?}: this runtime always isolates it"
                    )));
                }
            }
        }
        Ok(())
    }

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("{context}: {source}")]
    Io { context: String, source: io::Error },

    #[error("invalid JSON in {path}: {source}")]
    Json { path: PathBuf, source: serde_json::Error },

    #[error("system call failed: {0}")]
    Sys(#[from] nix::Error),

    /// O bundle/config.json está mal formado ou incoerente.
    #[error("invalid bundle: {0}")]
    Spec(String),

    /// O bundle pede algo que este runtime NÃO implementa. Recusa-se — nunca se ignora.
    #[error("unsupported: {0}")]
    Unsupported(String),

    #[error("digest mismatch for {what}: expected {expected}, got {actual}")]
    Digest { what: String, expected: String, actual: String },

    #[error("unsafe path refused: {0}")]
    UnsafePath(PathBuf),

    #[error("no such container: {0}")]
    NotFound(String),

    #[error("container already exists: {0}")]
    Conflict(String),

    #[error("container {id} is {status}, expected {expected}")]
    WrongState { id: String, status: String, expected: &'static str },

    #[error("cgroup: {0}")]
    Cgroup(String),

    #[error("container setup failed: {0}")]
    Setup(String),
}

impl Error {
    /// Constrói um `Error::Io` com contexto (o caminho ou a acção que falhou).
    pub fn io(context: impl Into<String>, source: io::Error) -> Self {
        Self::Io { context: context.into(), source }
    }

    /// Classe de saída, ao estilo do delonix: «não existe» (4) e «conflito» (5)
    /// distinguem-se de «rebentou» (1) sem ninguém ter de ler a mensagem.
    pub fn exit_code(&self) -> u8 {
        match self {
            Self::NotFound(_) => 4,
            Self::Conflict(_) | Self::WrongState { .. } => 5,
            Self::Spec(_) | Self::Unsupported(_) => 2,
            _ => 1,
        }
    }
}

/// Extensão para anexar contexto a um `io::Result` sem repetir `map_err` em todo o lado.
pub trait IoContext<T> {
    fn ctx(self, context: impl FnOnce() -> String) -> Result<T>;
}

impl<T> IoContext<T> for std::result::Result<T, io::Error> {
    fn ctx(self, context: impl FnOnce() -> String) -> Result<T> {
        self.map_err(|e| Error::io(context(), e))
    }
}

/// Identificadores de container: entram em caminhos de disco e de cgroup, logo lista branca.
pub fn valid_id(id: &str) -> Result<()> {
    let ok = !id.is_empty()
        && id.len() <= 64
        && !id.starts_with(['-', '.'])
        && id.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'.' | b'_' | b'-'));
    if ok { Ok(()) } else { Err(Error::Spec(format!("invalid container id {id:?}"))) }
}