lux_lib/operations/

pack.rs

use crate::build::utils;
use crate::build::utils::c_dylib_extension;
use crate::fs;
use crate::lockfile::LockedPackage;
use crate::luarocks;
use crate::luarocks::rock_manifest::DirOrFileEntry;
use crate::luarocks::rock_manifest::RockManifest;
use crate::luarocks::rock_manifest::RockManifestBin;
use crate::luarocks::rock_manifest::RockManifestConf;
use crate::luarocks::rock_manifest::RockManifestDoc;
use crate::luarocks::rock_manifest::RockManifestLib;
use crate::luarocks::rock_manifest::RockManifestLua;
use crate::luarocks::rock_manifest::RockManifestRoot;
use crate::tree::InstallTree;
use crate::tree::Tree;
use crate::tree::TreeError;
use bon::Builder;
use clean_path::Clean;
use itertools::Itertools;
use miette::Diagnostic;
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::collections::VecDeque;
use std::fs::File;
use std::io;
use std::io::Read;
use std::io::Write;
use std::path::Path;
use std::path::PathBuf;
use thiserror::Error;
use walkdir::WalkDir;
use zip::write::SimpleFileOptions;
use zip::ZipWriter;

#[cfg(unix)]
use std::os::unix::fs::PermissionsExt;

/// A binary rock packer
#[derive(Builder)]
#[builder(start_fn = new, finish_fn(name = _build, vis = ""))]
pub struct Pack {
    #[builder(start_fn)]
    dest_dir: PathBuf,
    #[builder(start_fn)]
    tree: Tree,
    #[builder(start_fn)]
    package: LockedPackage,
}

impl<State> PackBuilder<State>
where
    State: pack_builder::State + pack_builder::IsComplete,
{
    pub async fn pack(self) -> Result<PathBuf, PackError> {
        do_pack(self._build()).await
    }
}

#[derive(Error, Debug, Diagnostic)]
#[error("failed to pack rock")]
pub enum PackError {
    Zip(#[from] zip::result::ZipError),
    Io(#[from] io::Error),
    #[error(transparent)]
    #[diagnostic(transparent)]
    Fs(#[from] fs::FsError),
    Walkdir(#[from] walkdir::Error),
    #[error(transparent)]
    #[diagnostic(transparent)]
    Tree(#[from] TreeError),
    #[error("expected a `package.rockspec` in the package root.")]
    MissingRockspec,
}

async fn do_pack(args: Pack) -> Result<PathBuf, PackError> {
    let package = args.package;
    let tree = args.tree;
    let layout = tree.layout_for(&package.spec);
    let suffix = if is_binary_rock(&layout.lib) {
        format!("{}.rock", luarocks::current_platform_luarocks_identifier())
    } else {
        "all.rock".into()
    };
    let file_name = format!("{}-{}.{}", package.name(), package.version(), suffix);
    let temp_file_name = format!("{}-{}.{}.part", package.name(), package.version(), suffix);
    let temp_output_path = args.dest_dir.join(temp_file_name);
    let output_path = args.dest_dir.join(file_name);
    let file = fs::sync::create(&temp_output_path)?;
    let mut zip = ZipWriter::new(file);

    let lua_entries = add_rock_entries(&mut zip, &layout.src, "lua".into())?;
    let lib_entries = add_rock_entries(&mut zip, &layout.lib, "lib".into())?;
    let doc_entries = add_rock_entries(&mut zip, &layout.doc, "doc".into())?;
    let conf_entries = add_rock_entries(&mut zip, &layout.conf, "conf".into())?;
    // We copy entries from `etc` to the root directory, as luarocks doesn't have an etc directory.
    let temp_root_dir = fs::tempfile::tempdir()?;
    utils::recursive_copy_dir(&layout.etc, temp_root_dir.path()).await?;
    // prevent duplicate doc and conf entries
    let doc = temp_root_dir.path().join("doc");
    if doc.is_dir() {
        fs::tokio::remove_dir_all(&doc).await?;
    }
    let conf = temp_root_dir.path().join("conf");
    if conf.is_dir() {
        fs::tokio::remove_dir_all(&conf).await?;
    }
    // luarocks expects a <package>-<version>.rockspec,
    // so we copy it the package.rockspec to our temporary root directory and rename it
    if !layout.rockspec_path().is_file() {
        return Err(PackError::MissingRockspec);
    }
    let packed_rockspec_name = format!("{}-{}.rockspec", package.name(), package.version());
    let renamed_rockspec_entry = temp_root_dir.path().join(packed_rockspec_name);
    fs::tokio::copy(layout.rockspec_path(), &renamed_rockspec_entry).await?;
    let root_entries = add_rock_entries(&mut zip, temp_root_dir.path(), "".into())?;
    let mut bin_entries = HashMap::new();
    let lockfile = tree.lockfile()?;
    for relative_binary_path in lockfile
        .binaries(&package.id())
        .into_iter()
        .flat_map(|binaries| binaries.iter())
    {
        if let Some(binary_name) = relative_binary_path.clean().file_name() {
            let binary_path = tree.bin().join(binary_name);
            if binary_path.is_file() {
                let (path, digest) =
                    add_rock_entry(&mut zip, binary_path, &tree.bin(), &PathBuf::default())?;
                bin_entries.insert(path, digest);
            }
        }
    }
    let rock_manifest = RockManifest {
        lua: RockManifestLua {
            entries: lua_entries,
        },
        lib: RockManifestLib {
            entries: lib_entries,
        },
        doc: RockManifestDoc {
            entries: doc_entries,
        },
        conf: RockManifestConf {
            entries: conf_entries,
        },
        root: RockManifestRoot {
            entries: root_entries,
        },
        bin: RockManifestBin {
            entries: bin_entries,
        },
    };
    let manifest_str = rock_manifest.to_lua_string();
    let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
    zip.start_file("rock_manifest", options)?;
    zip.write_all(manifest_str.as_bytes())?;
    fs::tokio::rename(&temp_output_path, &output_path).await?;
    Ok(output_path)
}

fn is_binary_rock(lib_dir: &Path) -> bool {
    if !lib_dir.is_dir() {
        return false;
    }
    WalkDir::new(lib_dir).into_iter().any(|entry| {
        entry.is_ok_and(|entry| {
            let file = entry.into_path();
            file.is_file()
                && file
                    .extension()
                    .is_some_and(|ext| ext.to_string_lossy() == c_dylib_extension())
        })
    })
}

fn add_rock_entries(
    zip: &mut ZipWriter<File>,
    source_dir: &Path,
    zip_dir: PathBuf,
) -> Result<HashMap<PathBuf, DirOrFileEntry>, PackError> {
    let mut result = HashMap::new();
    if source_dir.is_dir() {
        for file in WalkDir::new(source_dir).into_iter().filter_map_ok(|entry| {
            let file = entry.into_path();
            if file.is_file() {
                Some(file)
            } else {
                None
            }
        }) {
            let file = file?;
            let (relative_path, digest) = add_rock_entry(zip, file, source_dir, &zip_dir)?;
            add_dir_or_file_entry(&mut result, &relative_path, digest);
        }
    }
    Ok(result)
}

fn add_rock_entry(
    zip: &mut ZipWriter<File>,
    file: PathBuf,
    source_dir: &Path,
    zip_dir: &Path,
) -> Result<(PathBuf, String), PackError> {
    let relative_path: PathBuf = file
        .strip_prefix(source_dir)
        .unwrap_or(file.as_path())
        .to_path_buf();
    let mut f = fs::sync::open(file)?;
    let mut buffer = Vec::new();
    f.read_to_end(&mut buffer)?;
    let digest = md5::compute(&buffer);

    #[cfg(target_family = "unix")]
    let options = SimpleFileOptions::default()
        .compression_method(zip::CompressionMethod::Stored)
        .unix_permissions(f.metadata()?.permissions().mode());
    #[cfg(target_family = "windows")]
    let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);

    zip.start_file(zip_dir.join(&relative_path).to_string_lossy(), options)?;
    zip.write_all(&buffer)?;
    Ok((relative_path, format!("{digest:x}")))
}

fn add_dir_or_file_entry(
    dir_map: &mut HashMap<PathBuf, DirOrFileEntry>,
    relative_path: &Path,
    digest: String,
) {
    let mut components = relative_path
        .components()
        .filter_map(|component| match component {
            std::path::Component::Normal(path) => Some(PathBuf::from(path)),
            _ => None,
        })
        .collect::<VecDeque<_>>();
    match &components.len() {
        n if *n > 1 => {
            if let Some(first_dir) = components.pop_front() {
                let remainder = components.iter().collect::<PathBuf>();
                match dir_map.entry(first_dir) {
                    Entry::Occupied(mut entry) => match entry.get_mut() {
                        DirOrFileEntry::DirEntry(entries) => {
                            add_dir_or_file_entry(entries, &remainder, digest);
                        }
                        DirOrFileEntry::FileEntry(_) => {
                            let mut entries = HashMap::new();
                            add_dir_or_file_entry(&mut entries, &remainder, digest);
                            entry.insert(DirOrFileEntry::DirEntry(entries));
                        }
                    },
                    Entry::Vacant(entry) => {
                        let mut entries = HashMap::new();
                        add_dir_or_file_entry(&mut entries, &remainder, digest);
                        entry.insert(DirOrFileEntry::DirEntry(entries));
                    }
                }
            }
        }
        _ => {
            dir_map.insert(
                relative_path.to_path_buf(),
                DirOrFileEntry::FileEntry(digest),
            );
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // non-regression for https://github.com/lumen-oss/lux/issues/2031
    #[test]
    fn add_dir_or_file_entry_preserves_siblings_and_nested_entries() {
        let mut entries = HashMap::new();

        add_dir_or_file_entry(&mut entries, Path::new("docs/a.txt"), "digest-a".into());
        add_dir_or_file_entry(&mut entries, Path::new("docs/b.txt"), "digest-b".into());
        add_dir_or_file_entry(
            &mut entries,
            Path::new("docs/nested/c.txt"),
            "digest-c".into(),
        );

        assert_eq!(
            entries,
            HashMap::from([(
                PathBuf::from("docs"),
                DirOrFileEntry::DirEntry(HashMap::from([
                    (
                        PathBuf::from("a.txt"),
                        DirOrFileEntry::FileEntry("digest-a".into())
                    ),
                    (
                        PathBuf::from("b.txt"),
                        DirOrFileEntry::FileEntry("digest-b".into())
                    ),
                    (
                        PathBuf::from("nested"),
                        DirOrFileEntry::DirEntry(HashMap::from([(
                            PathBuf::from("c.txt"),
                            DirOrFileEntry::FileEntry("digest-c".into()),
                        )])),
                    ),
                ])),
            )])
        );
    }

    // non-regression for https://github.com/lumen-oss/lux/issues/2116
    #[cfg(unix)]
    #[test]
    fn add_rock_entries_with_relative_source_dir() -> Result<(), PackError> {
        let temp = fs::tempfile::tempdir()?;
        let abs_source_dir = temp.path().join("src");
        fs::sync::create_dir_all(abs_source_dir.join("sub"))?;
        fs::sync::write(abs_source_dir.join("plainp.lua"), b"-- plainp")?;
        fs::sync::write(abs_source_dir.join("sub").join("mod.lua"), b"-- mod")?;

        // Express the source dir relative to the cwd, as `--tree ./tree` does.
        let relative_source_dir = pathdiff::diff_paths(&abs_source_dir, std::env::current_dir()?)
            .unwrap_or_else(|| unreachable!("temp dir and cwd share a root on unix"));
        assert!(relative_source_dir.is_dir());

        let expected_entries = HashMap::from([
            (
                PathBuf::from("plainp.lua"),
                DirOrFileEntry::FileEntry(format!("{:x}", md5::compute(b"-- plainp"))),
            ),
            (
                PathBuf::from("sub"),
                DirOrFileEntry::DirEntry(HashMap::from([(
                    PathBuf::from("mod.lua"),
                    DirOrFileEntry::FileEntry(format!("{:x}", md5::compute(b"-- mod"))),
                )])),
            ),
        ]);

        // The relative case is the regression, the absolute one the mainline behaviour.
        let source_dirs = [&relative_source_dir, &abs_source_dir];
        for (index, source_dir) in source_dirs.into_iter().enumerate() {
            let zip_path = temp.path().join(format!("out-{}.rock", index));
            let mut zip = ZipWriter::new(fs::sync::create(&zip_path)?);
            let entries = add_rock_entries(&mut zip, source_dir, "lua".into())?;
            zip.finish()?;

            let mut archive = zip::ZipArchive::new(fs::sync::open(&zip_path)?)?;
            assert_eq!(archive.len(), 2);
            assert!(archive.by_name("lua/plainp.lua").is_ok());
            let mut contents = Vec::new();
            let mut mod_file = archive.by_name("lua/sub/mod.lua")?;
            mod_file.read_to_end(&mut contents)?;
            assert_eq!(contents, b"-- mod");

            assert_eq!(entries, expected_entries);
        }

        Ok(())
    }
}