ZacharyZhang-NYandClaude Fable 5
fd5cff2de6
Second layer of platform gaps the mac/linux-only gate history left: unix-only test imports/helpers now cfg-gated (mermaid, fast-worktree, hunk-tracker, pager-render link test, three pty_e2e module decls), clippy-suggested cleanups in Windows-cfg code (file-utils classifier, tui console-mode restore, shared clipboard arboard-error flow, tools terminal closure, workspace capability tail), and `cargo update` of h2 (RUSTSEC-2026-0258) and webbrowser (RUSTSEC-2026-0257) so `cargo deny check advisories` passes again. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KSy9S31pZNWXtRZNVJ1sDf
119 lines
3.7 KiB
Rust
119 lines
3.7 KiB
Rust
//! Copy-on-Write file cloning using the reflink-copy crate.
|
|
//!
|
|
//! Uses reflink (CoW) when supported by the filesystem, with automatic
|
|
//! fallback to regular copy.
|
|
|
|
use std::path::Path;
|
|
|
|
use anyhow::Result;
|
|
|
|
/// Clone a file using CoW if supported, falling back to regular copy.
|
|
///
|
|
/// On filesystems that support it (APFS on macOS, Btrfs/XFS on Linux),
|
|
/// this creates a reflink which shares data blocks until modified.
|
|
/// On other filesystems, it performs a regular copy.
|
|
pub(crate) fn clone_file(src: &Path, dest: &Path) -> Result<()> {
|
|
reflink_copy::reflink_or_copy(src, dest)?;
|
|
// reflink (FICLONE) only clones data blocks, creating the dest with
|
|
// default umask permissions. Explicitly propagate the source mode so the
|
|
// executable bit etc. survive on reflink-capable filesystems.
|
|
let perms = std::fs::metadata(src)?.permissions();
|
|
std::fs::set_permissions(dest, perms)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Recreate `dst` as a symlink pointing at `target`, replacing any existing
|
|
/// entry at `dst`.
|
|
///
|
|
/// `symlink()` refuses to overwrite an existing path, so we remove `dst` first
|
|
/// (a missing `dst` is not an error).
|
|
pub(crate) fn replace_symlink(target: &Path, dst: &Path) -> std::io::Result<()> {
|
|
let _ = std::fs::remove_file(dst);
|
|
symlink_to(target, dst)
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn symlink_to(target: &Path, dst: &Path) -> std::io::Result<()> {
|
|
std::os::unix::fs::symlink(target, dst)
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
fn symlink_to(target: &Path, dst: &Path) -> std::io::Result<()> {
|
|
std::os::windows::fs::symlink_file(target, dst)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use tempfile::TempDir;
|
|
|
|
#[test]
|
|
fn test_clone_file_with_fallback() {
|
|
let temp = TempDir::new().unwrap();
|
|
let src = temp.path().join("source.txt");
|
|
let dest = temp.path().join("dest.txt");
|
|
|
|
std::fs::write(&src, "hello world").unwrap();
|
|
|
|
// Should work either via CoW or fallback
|
|
clone_file(&src, &dest).unwrap();
|
|
|
|
assert!(dest.exists());
|
|
assert_eq!(std::fs::read_to_string(&dest).unwrap(), "hello world");
|
|
}
|
|
|
|
#[test]
|
|
fn test_clone_file_binary() {
|
|
let temp = TempDir::new().unwrap();
|
|
let src = temp.path().join("source.bin");
|
|
let dest = temp.path().join("dest.bin");
|
|
|
|
let data: Vec<u8> = (0..=255).collect();
|
|
std::fs::write(&src, &data).unwrap();
|
|
|
|
clone_file(&src, &dest).unwrap();
|
|
|
|
assert_eq!(std::fs::read(&dest).unwrap(), data);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn test_clone_preserves_permissions() {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
|
|
let temp = TempDir::new().unwrap();
|
|
let src = temp.path().join("script.sh");
|
|
let dest = temp.path().join("script_copy.sh");
|
|
|
|
std::fs::write(&src, "#!/bin/bash\necho hello").unwrap();
|
|
|
|
// Make executable
|
|
let mut perms = std::fs::metadata(&src).unwrap().permissions();
|
|
perms.set_mode(0o755);
|
|
std::fs::set_permissions(&src, perms).unwrap();
|
|
|
|
clone_file(&src, &dest).unwrap();
|
|
|
|
let dest_perms = std::fs::metadata(&dest).unwrap().permissions();
|
|
assert_eq!(dest_perms.mode() & 0o777, 0o755);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn test_replace_symlink_overwrites_and_allows_dangling() {
|
|
let temp = TempDir::new().unwrap();
|
|
let dst = temp.path().join("link");
|
|
|
|
std::fs::write(&dst, "stale").unwrap();
|
|
// Target is deliberately dangling; it must still be created.
|
|
replace_symlink(Path::new("does-not-exist"), &dst).unwrap();
|
|
|
|
let meta = std::fs::symlink_metadata(&dst).unwrap();
|
|
assert!(meta.file_type().is_symlink(), "dst must be a symlink");
|
|
assert_eq!(
|
|
std::fs::read_link(&dst).unwrap(),
|
|
Path::new("does-not-exist")
|
|
);
|
|
}
|
|
}
|