Coverage / crates/flow/src/workspace.rs 77.9%

pub fn copy_tree(src: &Path, dir: &Path) -> Result<Files> {

    let mut files = Vec::new();

    std::fs::create_dir_all(dir)?;

    let walk = ignore::WalkBuilder::new(src)

        .hidden(false)

        .git_ignore(true)

        .require_git(false)

        .add_custom_ignore_filename(".oxyignore")

        .filter_entry(|e| e.file_name() != ".oxy" && e.file_name() != ".git")

        .build();

    for entry in walk {

        let entry = entry?;

        let rel = entry.path().strip_prefix(src)?;

        if rel.as_os_str().is_empty() {

            continue;

        }

        let rel_s = rel.to_string_lossy().replace('\\', "/");

        let target = dir.join(rel);

        let ft = entry.file_type().context("file type")?;

        if ft.is_dir() {

            std::fs::create_dir_all(&target)?;

        } else if ft.is_symlink() {

        } else if ft.is_file() {

            std::fs::copy(entry.path(), &target)?;

            files.push((rel_s, *blake3::hash(&std::fs::read(entry.path())?).as_bytes()));

    Ok(files)

}

pub fn image(dir: &Path, out: &Path) -> Result<()> {

    let used: u64 = ignore::WalkBuilder::new(dir)

        .hidden(false)

        .ignore(false)

        .git_ignore(false)

        .build()

        .flatten()

        .filter_map(|e| e.metadata().ok())

        .map(|m| m.len().max(4096))

        .sum();

    let mib = used * 12 / 10 / (1 << 20) + 512;

    let (uid, gid) = owner();

    let status = std::process::Command::new("mkfs.ext4")

        .args(["-q", "-F", "-L", "workspace", "-E"])

        .arg(format!("root_owner={uid}:{gid}"))

        .arg("-d")

        .arg(dir)

        .arg(out)

        .arg(format!("{mib}M"))

        .status()

        .context("run mkfs.ext4 (e2fsprogs 1.43 or later)")?;

    if !status.success() {

    }

    Ok(())

}

pub fn restore_times(dir: &Path, files: &Files, before: Option<&crate::cache::Sources>) -> (crate::cache::Sources, usize) {

    let mut out = crate::cache::Sources::new();

    let mut restored = 0;

    for (path, hash) in files {

        let p = dir.join(path);

        let Ok(md) = std::fs::symlink_metadata(&p) else { continue };

        if !md.is_file() {

            continue;

        }

        let hex = hex::encode(hash);

        let kept = before.and_then(|b| b.get(path)).filter(|(h, _)| *h == hex).map(|(_, t)| *t);

        let t = match kept {

            Some(t) => {

                let at = std::time::UNIX_EPOCH + std::time::Duration::from_secs(t.max(0) as u64);

                if std::fs::File::options().write(true).open(&p).and_then(|f| f.set_modified(at)).is_err() {

                }

                restored += 1;

                t

            None => md.modified().ok().and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok()).map(|d| d.as_secs() as i64).unwrap_or(0),

        out.insert(path.clone(), (hex, t));

    restore_dir_times(dir, Path::new(""), before, &mut out, &mut restored);

    (out, restored)

}

fn dir_key(rel: &Path) -> String {

    format!("{}/", rel.display())

}

fn restore_dir_times(

    root: &Path,

    rel: &Path,

    before: Option<&crate::cache::Sources>,

    out: &mut crate::cache::Sources,

    restored: &mut usize,

) {

    let here = root.join(rel);

    let Ok(entries) = std::fs::read_dir(&here) else { return };

    let mut names: Vec<(String, bool)> = Vec::new();

    for e in entries.flatten() {

        let is_dir = e.file_type().is_ok_and(|t| t.is_dir());

        names.push((e.file_name().to_string_lossy().into_owned(), is_dir));

    names.sort();

    for (name, is_dir) in &names {

        if *is_dir {

            restore_dir_times(root, &rel.join(name), before, out, restored);

        }

    let mut h = blake3::Hasher::new();

    for (name, is_dir) in &names {

        h.update(name.as_bytes());

        h.update(if *is_dir { b"/\n".as_slice() } else { b"\n".as_slice() });

    let hex = h.finalize().to_hex().to_string();

    let key = dir_key(rel);

    let kept = before.and_then(|b| b.get(&key)).filter(|(h, _)| *h == hex).map(|(_, t)| *t);

    let t = match kept {

        Some(t) => {

            let at = std::time::UNIX_EPOCH + std::time::Duration::from_secs(t.max(0) as u64);

            if std::fs::File::open(&here).and_then(|f| f.set_modified(at)).is_err() {

            }

            *restored += 1;

            t

        None => std::fs::metadata(&here)

            .ok()

            .and_then(|m| m.modified().ok())

            .and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok())

            .map(|d| d.as_secs() as i64)

            .unwrap_or(0),

    out.insert(key, (hex, t));

}

pub fn empty_ext4(out: &Path, mib: u32, label: &str) -> Result<()> {

    let (uid, gid) = owner();

    let status = std::process::Command::new("mkfs.ext4")

        .args(["-q", "-F", "-L", label, "-E"])

        .arg(format!("root_owner={uid}:{gid}"))

        .arg(out)

        .arg(format!("{mib}M"))

        .status()

        .context("run mkfs.ext4 (e2fsprogs 1.43 or later)")?;

    if !status.success() {

    }

    Ok(())

}

pub fn remove_tree(dir: &Path) -> std::io::Result<()> {

    match std::fs::remove_dir_all(dir) {

        Ok(()) => Ok(()),

        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),

}

fn owner() -> (u32, u32) {

        unsafe { (libc::getuid(), libc::getgid()) }

}

    fn secs(p: &Path) -> i64 {

        std::fs::metadata(p).unwrap().modified().unwrap().duration_since(UNIX_EPOCH).unwrap().as_secs() as i64

    }

    fn unchanged_sources_get_their_cached_times_back() {

        let dir = tempfile::tempdir().unwrap();

        for (name, text) in [("same.rs", "a"), ("changed.rs", "b2"), ("new.rs", "c")] {

            std::fs::write(dir.path().join(name), text).unwrap();

        }

        std::os::unix::fs::symlink("same.rs", dir.path().join("link.rs")).unwrap();

        let h = |t: &str| *blake3::hash(t.as_bytes()).as_bytes();

        let files: Files =

            vec![("same.rs".into(), h("a")), ("changed.rs".into(), h("b2")), ("new.rs".into(), h("c")), ("link.rs".into(), h("same.rs"))];

        let now = secs(&dir.path().join("same.rs"));

        let before: crate::cache::Sources =

            [("same.rs".to_string(), (hex::encode(h("a")), 1_000_000)), ("changed.rs".to_string(), (hex::encode(h("b1")), 1_000_000))]

                .into();

        let (sources, restored) = restore_times(dir.path(), &files, Some(&before));

        assert_eq!(restored, 1);

        assert_eq!(secs(&dir.path().join("same.rs")), 1_000_000, "unchanged: fresh to cargo");

        assert!(secs(&dir.path().join("changed.rs")) >= now, "changed: newer than the cached build");

        assert_eq!(sources["same.rs"], (hex::encode(h("a")), 1_000_000));

        assert_eq!(sources["changed.rs"].0, hex::encode(h("b2")), "kept with its new content");

        assert!(sources.contains_key("new.rs") && !sources.contains_key("link.rs"), "files only");

        let (again, restored) = restore_times(dir.path(), &files, None);

        assert_eq!((restored, again.len()), (0, 4));

        assert!(again.contains_key("/"));

        std::fs::create_dir(dir.path().join("migrations")).unwrap();

        std::fs::write(dir.path().join("migrations/0001.sql"), "x").unwrap();

        let mut files = files;

        files.push(("migrations/0001.sql".into(), h("x")));

        let (mut kept, _) = restore_times(dir.path(), &files, None);

        kept.get_mut("migrations/").unwrap().1 = 2_000_000;

        kept.get_mut("migrations/0001.sql").unwrap().1 = 2_000_000;

        let (_, restored) = restore_times(dir.path(), &files, Some(&kept));

        assert_eq!(secs(&dir.path().join("migrations")), 2_000_000, "unchanged listing: its old time");

        assert!(restored >= 2);

        std::fs::write(dir.path().join("migrations/0002.sql"), "y").unwrap();

        files.push(("migrations/0002.sql".into(), h("y")));

        let (now_sources, _) = restore_times(dir.path(), &files, Some(&kept));

        assert!(secs(&dir.path().join("migrations")) > 2_000_000, "a new entry: it looks changed");

        assert_ne!(now_sources["migrations/"].0, kept["migrations/"].0);

    }