mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 19:14:26 +00:00
345 lines
14 KiB
Rust
345 lines
14 KiB
Rust
//! Publication succeeds independently of best-effort cleanup of the previous entry set.
|
|
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
|
|
|
use craft_pcraft_bundle::{DirectoryBundle, DirectoryBundleWriter, Limits, ObjectKind, ZipBundleWriter};
|
|
use craft_pcraft_format::{COMPOSITE, FULL_COMPOSITE, MANIFEST, THUMB};
|
|
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::atomic::{AtomicU64, Ordering};
|
|
|
|
const OLD: &[u8] = br#"{"revision":1}"#;
|
|
const NEW: &[u8] = br#"{"revision":2}"#;
|
|
|
|
struct Temporary(PathBuf);
|
|
|
|
impl Temporary {
|
|
fn new() -> Self {
|
|
static NEXT: AtomicU64 = AtomicU64::new(0);
|
|
let path = std::env::temp_dir().join(format!("craft-bundle-cleanup-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
|
|
fs::create_dir(&path).unwrap();
|
|
Self(path)
|
|
}
|
|
|
|
fn bundle(&self) -> PathBuf {
|
|
self.0.join("document.pcraft")
|
|
}
|
|
}
|
|
|
|
impl Drop for Temporary {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
fn entries(manifest: &[u8]) -> ZipBundleWriter {
|
|
let mut bundle = ZipBundleWriter::default();
|
|
bundle.set_manifest(manifest.to_vec()).unwrap();
|
|
bundle
|
|
}
|
|
|
|
fn assert_manifest(root: &Path, expected: &[u8]) {
|
|
assert_eq!(fs::read(root.join(MANIFEST)).unwrap(), expected);
|
|
assert_eq!(DirectoryBundle::open(root, Limits::default()).unwrap().manifest().unwrap(), expected);
|
|
}
|
|
|
|
#[test]
|
|
fn non_file_stale_object_does_not_fail_the_committed_save() {
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
writer.save_directory(&root, entries(OLD)).unwrap();
|
|
let stuck = root.join("tiles").join(format!("{}.zst", "0".repeat(64)));
|
|
fs::create_dir_all(stuck.join("inner")).unwrap();
|
|
fs::write(stuck.join("inner/keep"), b"not an object file").unwrap();
|
|
|
|
let stats = writer.save_directory(&root, entries(NEW)).expect("cleanup cannot fail after manifest publication");
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(stats.removed, 0);
|
|
assert_eq!(fs::read(stuck.join("inner/keep")).unwrap(), b"not an object file");
|
|
}
|
|
|
|
#[test]
|
|
fn cleanup_removes_only_canonical_stale_regular_objects_and_reuses_current_objects() {
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
let mut first = entries(OLD);
|
|
let retained = first.add_object(ObjectKind::Tile, b"still referenced").unwrap();
|
|
let stale = first.add_object(ObjectKind::Blob, b"old blob").unwrap();
|
|
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
|
|
first.set_preview(preview, b"old preview".to_vec()).unwrap();
|
|
}
|
|
writer.save_directory(&root, first).unwrap();
|
|
let retained_bytes = fs::read(root.join(&retained)).unwrap();
|
|
let unrelated = [
|
|
"tiles/personal-notes.zst".to_string(),
|
|
"blobs/012345.zst".to_string(),
|
|
format!("blobs/{}.zst", "A".repeat(64)),
|
|
format!("tiles/{}.zst.backup", "b".repeat(64)),
|
|
];
|
|
for path in &unrelated {
|
|
fs::write(root.join(path), b"unrelated").unwrap();
|
|
}
|
|
let nested = root.join("blobs/not-an-object-folder");
|
|
fs::create_dir(&nested).unwrap();
|
|
fs::write(nested.join(format!("{}.zst", "c".repeat(64))), b"unrelated nested file").unwrap();
|
|
let mut second = entries(NEW);
|
|
assert_eq!(second.add_object(ObjectKind::Tile, b"still referenced").unwrap(), retained);
|
|
let stats = writer.save_directory(&root, second).unwrap();
|
|
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(stats.removed, 1);
|
|
assert_eq!(stats.reused, 1);
|
|
assert_eq!(stats.reused_objects.as_slice(), std::slice::from_ref(&retained));
|
|
assert!(stats.written_objects.is_empty());
|
|
assert!(!root.join(stale).exists());
|
|
assert_eq!(fs::read(root.join(retained)).unwrap(), retained_bytes);
|
|
for path in unrelated {
|
|
assert_eq!(fs::read(root.join(path)).unwrap(), b"unrelated");
|
|
}
|
|
assert!(nested.is_dir());
|
|
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
|
|
assert!(!root.join(preview).exists());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn stale_preview_directories_are_preserved_after_commit() {
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
writer.save_directory(&root, entries(OLD)).unwrap();
|
|
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
|
|
fs::create_dir_all(root.join(preview)).unwrap();
|
|
fs::write(root.join(preview).join("keep"), b"directory contents").unwrap();
|
|
}
|
|
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(stats.removed, 0);
|
|
for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] {
|
|
assert_eq!(fs::read(root.join(preview).join("keep")).unwrap(), b"directory contents");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn required_non_file_objects_and_previews_fail_before_manifest_publication() {
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
writer.save_directory(&root, entries(OLD)).unwrap();
|
|
let mut changed = entries(NEW);
|
|
let object = changed.add_object(ObjectKind::Tile, b"required object").unwrap();
|
|
fs::create_dir_all(root.join(&object)).unwrap();
|
|
assert!(writer.save_directory(&root, changed).is_err());
|
|
assert_manifest(&root, OLD);
|
|
|
|
for preview in [THUMB, COMPOSITE] {
|
|
fs::create_dir_all(root.join(preview)).unwrap();
|
|
let mut changed = entries(NEW);
|
|
changed.set_preview(preview, b"required preview".to_vec()).unwrap();
|
|
assert!(writer.save_directory(&root, changed).is_err());
|
|
assert_manifest(&root, OLD);
|
|
}
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
#[test]
|
|
fn locked_stale_object_and_preview_do_not_fail_commit_and_are_collected_on_retry() {
|
|
use std::fs::OpenOptions;
|
|
use std::os::windows::fs::OpenOptionsExt;
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
let mut first = entries(OLD);
|
|
let stale = first.add_object(ObjectKind::Tile, b"locked stale tile").unwrap();
|
|
first.set_preview(FULL_COMPOSITE, b"locked preview".to_vec()).unwrap();
|
|
writer.save_directory(&root, first).unwrap();
|
|
let tile_lock = OpenOptions::new().read(true).share_mode(0).open(root.join(&stale)).unwrap();
|
|
let preview_lock = OpenOptions::new().read(true).share_mode(0).open(root.join(FULL_COMPOSITE)).unwrap();
|
|
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(stats.removed, 0);
|
|
assert!(root.join(&stale).exists());
|
|
assert!(root.join(FULL_COMPOSITE).exists());
|
|
drop(tile_lock);
|
|
drop(preview_lock);
|
|
let retry = writer.save_directory(&root, entries(NEW)).unwrap();
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(retry.removed, 1);
|
|
assert!(!root.join(stale).exists());
|
|
assert!(!root.join(FULL_COMPOSITE).exists());
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn cleanup_preserves_symlinks_and_does_not_traverse_linked_directories() {
|
|
use std::os::unix::fs::symlink;
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let outside = temp.0.join("outside");
|
|
fs::create_dir(&outside).unwrap();
|
|
let object_name = format!("{}.zst", "d".repeat(64));
|
|
fs::write(outside.join(&object_name), b"outside object").unwrap();
|
|
fs::write(outside.join("preview.png"), b"outside preview").unwrap();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
writer.save_directory(&root, entries(OLD)).unwrap();
|
|
symlink(&outside, root.join("blobs")).unwrap();
|
|
symlink(&outside, root.join("composite")).unwrap();
|
|
symlink(outside.join("preview.png"), root.join(THUMB)).unwrap();
|
|
fs::create_dir(root.join("tiles")).unwrap();
|
|
let linked_object = root.join("tiles").join(&object_name);
|
|
symlink(outside.join(&object_name), &linked_object).unwrap();
|
|
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(stats.removed, 0);
|
|
assert_eq!(fs::read(outside.join(object_name)).unwrap(), b"outside object");
|
|
assert_eq!(fs::read(outside.join("preview.png")).unwrap(), b"outside preview");
|
|
for link in [root.join("blobs"), root.join("composite"), root.join(THUMB), linked_object] {
|
|
assert!(fs::symlink_metadata(link).unwrap().file_type().is_symlink());
|
|
}
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn required_symlink_objects_and_previews_still_fail_before_commit() {
|
|
use std::os::unix::fs::symlink;
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let outside = temp.0.join("outside-file");
|
|
fs::write(&outside, b"unchanged outside bytes").unwrap();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
writer.save_directory(&root, entries(OLD)).unwrap();
|
|
let mut changed = entries(NEW);
|
|
let object = changed.add_object(ObjectKind::Tile, b"required object").unwrap();
|
|
fs::create_dir(root.join("tiles")).unwrap();
|
|
symlink(&outside, root.join(object)).unwrap();
|
|
assert!(writer.save_directory(&root, changed).is_err());
|
|
assert_manifest(&root, OLD);
|
|
symlink(&outside, root.join(THUMB)).unwrap();
|
|
let mut changed = entries(NEW);
|
|
changed.set_preview(THUMB, b"new preview".to_vec()).unwrap();
|
|
assert!(writer.save_directory(&root, changed).is_err());
|
|
assert_manifest(&root, OLD);
|
|
assert_eq!(fs::read(outside).unwrap(), b"unchanged outside bytes");
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
#[test]
|
|
fn cleanup_does_not_traverse_windows_directory_junctions() {
|
|
use std::os::windows::process::CommandExt;
|
|
struct Junction(PathBuf);
|
|
impl Drop for Junction {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir(&self.0);
|
|
}
|
|
}
|
|
fn junction(link: PathBuf, target: &Path) -> Junction {
|
|
// Fixture-owned absolute paths only; junctions require no symlink privilege.
|
|
assert!(link.is_absolute() && target.is_absolute());
|
|
let output = std::process::Command::new("cmd")
|
|
.args(["/C", "mklink", "/J"])
|
|
.arg(&link)
|
|
.arg(target)
|
|
.creation_flags(0x0800_0000) // CREATE_NO_WINDOW
|
|
.output()
|
|
.unwrap();
|
|
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
|
|
Junction(link)
|
|
}
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let outside = temp.0.join("outside");
|
|
fs::create_dir(&outside).unwrap();
|
|
let object_name = format!("{}.zst", "e".repeat(64));
|
|
fs::write(outside.join(&object_name), b"outside object").unwrap();
|
|
fs::write(outside.join("preview.png"), b"outside preview").unwrap();
|
|
fs::write(outside.join("full.png"), b"outside full preview").unwrap();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
writer.save_directory(&root, entries(OLD)).unwrap();
|
|
let _objects = junction(root.join("blobs"), &outside);
|
|
let _previews = junction(root.join("composite"), &outside);
|
|
let stats = writer.save_directory(&root, entries(NEW)).unwrap();
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(stats.removed, 0);
|
|
assert_eq!(fs::read(outside.join(object_name)).unwrap(), b"outside object");
|
|
assert_eq!(fs::read(outside.join("preview.png")).unwrap(), b"outside preview");
|
|
assert_eq!(fs::read(outside.join("full.png")).unwrap(), b"outside full preview");
|
|
assert!(root.join("blobs").exists());
|
|
assert!(root.join("composite").exists());
|
|
}
|
|
|
|
#[cfg(any(unix, windows))]
|
|
#[test]
|
|
fn manifest_symlink_is_refused_before_writing_any_objects_or_previews() {
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
writer.save_directory(&root, entries(OLD)).unwrap();
|
|
assert_manifest(&root, OLD); // Ordinary publication remains supported.
|
|
let external = temp.0.join("external-manifest.json");
|
|
fs::write(&external, b"unchanged external manifest").unwrap();
|
|
fs::remove_file(root.join(MANIFEST)).unwrap();
|
|
#[cfg(unix)]
|
|
std::os::unix::fs::symlink(&external, root.join(MANIFEST)).unwrap();
|
|
#[cfg(windows)]
|
|
if let Err(error) = std::os::windows::fs::symlink_file(&external, root.join(MANIFEST)) {
|
|
if error.raw_os_error() == Some(1314) || error.kind() == std::io::ErrorKind::Unsupported {
|
|
eprintln!("SKIP manifest symlink fixture: {error}");
|
|
return;
|
|
}
|
|
panic!("create manifest symlink fixture: {error}");
|
|
}
|
|
let mut changed = entries(NEW);
|
|
changed.add_object(ObjectKind::Tile, b"must not write tile").unwrap();
|
|
changed.add_object(ObjectKind::Blob, b"must not write blob").unwrap();
|
|
changed.set_preview(THUMB, b"must not write thumbnail".to_vec()).unwrap();
|
|
changed.set_preview(FULL_COMPOSITE, b"must not write composite".to_vec()).unwrap();
|
|
assert!(writer.save_directory(&root, changed).is_err());
|
|
assert_eq!(fs::read(&external).unwrap(), b"unchanged external manifest");
|
|
assert!(fs::symlink_metadata(root.join(MANIFEST)).unwrap().file_type().is_symlink());
|
|
for unwritten in ["tiles", "blobs", THUMB, "composite"] {
|
|
assert!(!root.join(unwritten).exists(), "manifest refusal must precede {unwritten} publication");
|
|
}
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn chosen_root_symlink_cleanup_works_with_search_only_root_and_composite_permissions() {
|
|
use std::os::unix::fs::{PermissionsExt, symlink};
|
|
struct Restore(PathBuf, fs::Permissions);
|
|
impl Restore {
|
|
fn restrict(path: &Path) -> Self {
|
|
let old = fs::metadata(path).unwrap().permissions();
|
|
fs::set_permissions(path, fs::Permissions::from_mode(0o300)).unwrap();
|
|
Self(path.to_path_buf(), old)
|
|
}
|
|
}
|
|
impl Drop for Restore {
|
|
fn drop(&mut self) {
|
|
let _ = fs::set_permissions(&self.0, self.1.clone());
|
|
}
|
|
}
|
|
let temp = Temporary::new();
|
|
let root = temp.bundle();
|
|
let mut writer = DirectoryBundleWriter::default();
|
|
let mut first = entries(OLD);
|
|
let stale = first.add_object(ObjectKind::Blob, b"stale blob").unwrap();
|
|
first.set_preview(THUMB, b"stale thumbnail".to_vec()).unwrap();
|
|
first.set_preview(COMPOSITE, b"stale preview".to_vec()).unwrap();
|
|
writer.save_directory(&root, first).unwrap();
|
|
let chosen = temp.0.join("chosen.pcraft");
|
|
symlink(&root, &chosen).unwrap();
|
|
let composite_mode = Restore::restrict(&root.join("composite"));
|
|
let root_mode = Restore::restrict(&root);
|
|
let result = writer.save_directory(&chosen, entries(NEW));
|
|
drop(root_mode);
|
|
drop(composite_mode);
|
|
let stats = result.expect("chosen root resolves before cleanup; traversal does not require directory read permission");
|
|
assert_manifest(&root, NEW);
|
|
assert_eq!(stats.removed, 1);
|
|
assert!(!root.join(stale).exists());
|
|
assert!(!root.join(THUMB).exists());
|
|
assert!(!root.join(COMPOSITE).exists());
|
|
assert!(fs::symlink_metadata(chosen).unwrap().file_type().is_symlink());
|
|
}
|