dkl/src/lib.rs

pub mod apply;
pub mod rc;
pub mod cgroup;
pub mod human;
pub mod bootstrap;
pub mod dls;
pub mod dynlay;
pub mod fs;
pub mod logger;
pub mod proxy;

#[derive(Debug, Default, serde::Deserialize, serde::Serialize)]
pub struct Config {
    pub layers: Vec<String>,
    pub root_user: RootUser,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub mounts: Vec<Mount>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub files: Vec<File>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub groups: Vec<Group>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub users: Vec<User>,
}

#[derive(Debug, Default, serde::Deserialize, serde::Serialize)]
pub struct RootUser {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password_hash: Option<String>,
    pub authorized_keys: Vec<String>,
}

#[derive(Debug, Default, serde::Deserialize, serde::Serialize)]
pub struct Mount {
    pub dev: String,
    pub path: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<String>,
}

#[derive(Debug, serde::Deserialize, serde::Serialize)]
pub struct Group {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gid: Option<u32>,
}

#[derive(Debug, serde::Deserialize, serde::Serialize)]
pub struct User {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uid: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gid: Option<u32>,
}

#[derive(Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
pub struct File {
    pub path: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mode: Option<u32>,
    #[serde(flatten)]
    pub kind: FileKind,
}

#[derive(Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
#[serde(rename_all = "lowercase")]
pub enum FileKind {
    Content(String),
    Content64(String),
    Symlink(String),
    Dir(bool),
}

// ------------------------------------------------------------------------

impl Config {
    pub fn has_file(&self, path: &str) -> bool {
        self.files.iter().any(|f| f.path == path)
    }
    pub fn file(&self, path: &str) -> Option<&File> {
        self.files.iter().find(|f| f.path == path)
    }
}

pub fn base64_decode(s: &str) -> Result<Vec<u8>, base64::DecodeError> {
    use base64::{prelude::BASE64_STANDARD_NO_PAD as B64, Engine as _};
    B64.decode(s.trim_end_matches('='))
}

pub fn base64_encode(b: &[u8]) -> String {
    use base64::{prelude::BASE64_STANDARD as B64, Engine as _};
    B64.encode(b)
}