wapm_to_webc/

unpack.rs

use std::{
    collections::{BTreeSet, VecDeque},
    path::{Path, PathBuf},
};

use anyhow::Context;
use clap::Parser;
use wapm_targz_to_pirita::ConvertError;
use webc::{
    v1::{DirOrFileWithBytes, FsEntryType, ParseOptions, Volume, WebC},
    PathSegments,
};

use crate::pack::PackOptions;

#[derive(Debug, Parser)]
pub struct UnpackOptions {
    #[clap(name = "INFILE")]
    pub infile: PathBuf,
    /// Output file name
    #[clap(name = "OUTPATH")]
    pub out: PathBuf,
}

impl UnpackOptions {
    pub fn run(&self) -> Result<(), anyhow::Error> {
        let infile = std::fs::read(Path::new(&self.infile))
            .map_err(|e| ConvertError::Io(self.infile.display().to_string(), e))?;

        match webc::detect(infile.as_slice())? {
            webc::Version::V1 => {
                let webc = WebC::parse(&infile, &ParseOptions::default())?;
                unpack_webc(&webc, &self.out)?;
            }
            other => anyhow::bail!("Unsupported WEBC version, {other}"),
        }

        Ok(())
    }
}

pub(crate) fn unpack_volume<'a>(
    target_dir: &Path,
    volume: &Volume<'a>,
) -> Result<(), anyhow::Error> {
    for atom in volume.get_all_files_and_directories_with_bytes()? {
        match atom {
            DirOrFileWithBytes::Dir { path } => {
                std::fs::create_dir_all(target_dir.join(&path))
                    .map_err(|e| anyhow::anyhow!("{e}"))
                    .with_context(|| {
                        anyhow::anyhow!("failed to create dir {}", target_dir.join(&path).display())
                    })?;
            }
            DirOrFileWithBytes::File { path, bytes } => {
                let target_path = target_dir.join(path);
                if let Some(parent) = target_path.parent() {
                    std::fs::create_dir_all(&parent)
                        .map_err(|e| anyhow::anyhow!("{e}"))
                        .with_context(|| {
                            anyhow::anyhow!("failed to create dir {}", parent.display())
                        })?;
                }
                let bytes_len = bytes.len();
                std::fs::write(&target_path, bytes)
                    .map_err(|e| anyhow::anyhow!("{e}"))
                    .with_context(|| {
                        anyhow::anyhow!(
                            "failed to write {bytes_len} bytes into {}",
                            target_path.display()
                        )
                    })?;
            }
        }
    }

    Ok(())
}

pub(crate) fn unpack_webc<'a>(webc: &WebC<'a>, target_dir: &PathBuf) -> Result<(), anyhow::Error> {
    if !target_dir.is_dir() {
        return Err(anyhow::anyhow!(
            "Output path {} is not a directory",
            target_dir.display()
        ));
    }

    let manifest = serde_json::to_string_pretty(&webc.manifest)?;
    std::fs::write(target_dir.clone().join("wapm.v1.json"), manifest.as_bytes())?;
    std::fs::create_dir_all(target_dir.clone().join("atoms"));

    let target_path = target_dir.clone().join("atoms");
    std::fs::create_dir_all(&target_path)?;
    unpack_volume(&target_path, &webc.atoms)?;

    for (volume_name, volume) in webc.volumes.iter() {
        let target_path = target_dir.clone().join(volume_name);
        std::fs::create_dir_all(&target_path)?;
        unpack_volume(&target_path, &volume)?;
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use std::collections::HashSet;

    use tempfile::TempDir;
    use webc::{v2::read::OwnedReader, Container};

    use crate::PackOptions;

    use super::*;

    #[test]
    pub(crate) fn test_pack_unpack() {
        let file = include_bytes!("../test/fixtures/bindings-package-test-3.webc");
        let tmp = TempDir::new().unwrap();
        let tmp_tar_gz_folder = tmp.path();
        let webc_sourcefile = tmp_tar_gz_folder.join("webc-source.webc");
        let webc_targetfile = tmp_tar_gz_folder.join("webc-target.webc");
        let out = tmp_tar_gz_folder.join("unpacked");
        let _ = std::fs::create_dir_all(&out);

        std::fs::write(&webc_sourcefile, file).unwrap();

        let unpack_options = UnpackOptions {
            infile: webc_sourcefile.clone(),
            out: out.clone(),
        }
        .run()
        .unwrap();

        let unpack_options = PackOptions {
            inpath: out.clone(),
            out: webc_targetfile.clone(),
        }
        .run()
        .unwrap();

        let loaded_source = std::fs::read(&webc_sourcefile).unwrap();
        let loaded_target = std::fs::read(&webc_targetfile).unwrap();

        // Note: we can unpack WEBC v1 and v2, but packing will always generate
        // a WEBC v2.
        let webc_source = Container::from_disk(&webc_sourcefile).unwrap();
        let webc_target = Container::from_disk(webc_targetfile).unwrap();

        let source_atoms = webc_source.atoms();
        let target_atoms = webc_target.atoms();

        pretty_assertions::assert_eq!(
            source_atoms.keys().collect::<BTreeSet<_>>(),
            target_atoms.keys().collect::<BTreeSet<_>>()
        );

        let source_volumes = webc_source.volumes();
        let target_volumes = webc_target.volumes();

        pretty_assertions::assert_eq!(
            source_volumes.keys().collect::<BTreeSet<_>>(),
            target_volumes.keys().collect::<BTreeSet<_>>()
        );

        for (k, source_volume) in &source_volumes {
            assert_eq!(
                file_names(source_volume),
                file_names(&target_volumes[k]),
                "Volume {k:?} mismatch",
            );
        }
    }
}

fn file_names(volume: &webc::compat::Volume) -> BTreeSet<String> {
    fn read_dir(
        volume: &webc::compat::Volume,
        path: &mut PathSegments,
        filenames: &mut BTreeSet<String>,
    ) {
        let entries = volume.read_dir(&*path).unwrap();

        for (segment, meta) in entries {
            path.push(segment.clone());
            filenames.insert(path.to_string());

            if let webc::compat::Metadata::Dir = meta {
                read_dir(volume, path, filenames);
            }

            path.pop();
        }
    }

    let mut filenames = BTreeSet::new();
    let mut path = PathSegments::ROOT;

    read_dir(volume, &mut path, &mut filenames);

    filenames
}