Struct eto::Metadata

source ·

pub struct Metadata {
    pub version: String,
    pub ignore: Vec<String>,
}

Fields§

§version: String

The current version of the installation.

§ignore: Vec<String>

Files to ignore when generating a package.

Implementations§

source §

impl Metadata

source

pub fn from_dir<P: AsRef<Path>>(directory: P) -> Result<Self, Error>

Examples found in repository ?

src/package/mod.rs (line 112)

pub fn apply_to_directory(package_path: &Path, directory_path: &Path) -> Result<(), Error> {
    // Check the directory is an eto directory and load its metadata
    let metadata =
        Metadata::from_dir(directory_path).context("directory is not an eto tracked directory")?;

    // Open the package
    let mut file = open_package_file(package_path)?;

    // Load the manifest from the package
    let manifest = read_manifest(&mut file)?;
    // Verify current version matches the manifest old version
    if manifest.diff.old_version != metadata.version {
        bail!(
            "package was made for version \"{}\", but current version is \"{}\"",
            manifest.diff.old_version,
            metadata.version
        );
    }

    // Apply changes from the manifest
    read_unpack_files(&mut file, directory_path).context("failed to decode gzip data block")?;
    for delete in &manifest.diff.delete {
        event!(Level::INFO, path = delete.display().to_string(), "delete");

        let mut target = directory_path.to_owned();
        target.push(delete);
        let result = std::fs::remove_file(target);

        // We don't particularly care if this doesn't succeed, but if it doesn't at least log it
        if result.is_err() {
            event!(Level::WARN, "attempted to remove file that doesn't exist");
        }
    }

    Ok(())
}

More examples

Hide additional examples

src/state.rs (line 31)

    pub fn read_dir(directory: &Path) -> Result<Self, Error> {
        event!(
            Level::INFO,
            directory = directory.display().to_string(),
            "reading state"
        );

        let mut files = HashMap::new();

        // Read state metadata
        let metadata = Metadata::from_dir(directory)?;
        event!(Level::INFO, version = metadata.version, "metadata");

        // Compile ignore patterns
        let ignores: Result<Vec<_>, _> = metadata
            .ignore
            .into_iter()
            .map(|ignore| Pattern::new(&ignore))
            .collect();
        let mut ignores = ignores?;

        // Always ignore eto.log
        ignores.push(Pattern::new("eto.log").unwrap());

        // Read all state files (this includes the metadata file intentionally)
        'outer: for entry in WalkDir::new(directory) {
            let entry = entry?;
            let path = entry.path();

            // We don't handle directories directly, just files
            if entry.path().is_dir() {
                continue;
            }

            let path_str = path.display().to_string();
            event!(Level::DEBUG, path = path_str, "checking path");

            // Check if we need to ignore this
            let diff_path = diff_paths(path, directory).unwrap();
            for ignore in &ignores {
                if ignore.matches_path(&diff_path) {
                    event!(Level::DEBUG, path = path_str, "ignoring");
                    continue 'outer;
                }
            }

            // We've found a file, hash it so we can track changes
            let bytes = std::fs::read(path).context("failed to read file to track")?;
            let hash = sha256::digest(bytes.as_slice());

            event!(
                Level::DEBUG,
                path = diff_path.display().to_string(),
                hash,
                "adding"
            );
            files.insert(diff_path, hash);
        }

        Ok(Self {
            version: metadata.version,
            files,
        })
    }