diff --git a/src/interactive/app/deletion_progress.rs b/src/interactive/app/deletion_progress.rs index 82caf0b1..435cc26b 100644 --- a/src/interactive/app/deletion_progress.rs +++ b/src/interactive/app/deletion_progress.rs @@ -113,7 +113,13 @@ impl AppState { if self.read_only { anyhow::bail!(self.language.ui_text().snapshots_read_only); } - if self.scan.is_some() { + // Cleanup discovery stages candidates outside the visible tree and snapshots must + // match the scan, so only ordinary scans tolerate entries disappearing mid-way. + if self + .scan + .as_ref() + .is_some_and(|scan| self.clean_hub.is_some() || scan.snapshot_export.is_some()) + { anyhow::bail!(self.language.ui_text().traversal_running); } let Some(pane) = &window.mark else { @@ -243,6 +249,7 @@ impl AppState { let mut deltas = HashMap::::new(); let mut parents = HashMap::>::new(); + let mut removed_nodes = HashSet::new(); for &index in &roots { let Some(data) = tree.tree().data(index) else { continue; @@ -268,9 +275,22 @@ impl AppState { let mut pending = vec![index]; while let Some(index) = pending.pop() { deletion.children.remove(&index); + if self.scan.is_some() { + removed_nodes.insert(index); + } pending.extend(tree.tree().children(index)); } } + // A scan that is still running must not integrate queued entries into removed nodes, + // whose tree slots are about to become reusable. + if self + .scan + .as_mut() + .is_some_and(|scan| !scan.active_traversal.forget_removed_nodes(&removed_nodes)) + { + self.scan = None; + tree.traversal.cost = Some(tree.traversal.start_time.elapsed()); + } for target in &mut deletion.targets { if target.index.is_some_and(|index| roots.contains(&index)) { target.index = None; diff --git a/src/interactive/app/tests/journeys_with_writes.rs b/src/interactive/app/tests/journeys_with_writes.rs index 4c233111..faf51966 100644 --- a/src/interactive/app/tests/journeys_with_writes.rs +++ b/src/interactive/app/tests/journeys_with_writes.rs @@ -149,14 +149,14 @@ fn refresh_discards_marks_before_reusing_tree_indices() -> Result<()> { } #[test] -fn deletion_and_trash_are_blocked_until_scan_finishes() -> Result<()> { +fn deletion_works_during_scans_unless_a_snapshot_is_pending() -> Result<()> { use crate::interactive::app::{state::FilesystemScan, tree_view::TreeView}; use dua::traverse::BackgroundTraversal; let dir = TempDir::new()?; let root = dir.path().join("to-delete"); fs::create_dir(&root)?; - fs::write(root.join("file"), b"keep until the scan finishes")?; + fs::write(root.join("file"), b"content")?; let (mut terminal, mut app) = initialized_app_and_terminal_from_paths(std::slice::from_ref(&root))?; app.process_events( @@ -181,7 +181,7 @@ fn deletion_and_trash_are_blocked_until_scan_finishes() -> Result<()> { )?, previous_selection: None, previous_cleanup_view: None, - snapshot_export: None, + snapshot_export: Some((dir.path().join("snapshot"), None)), }); let delete_key = KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL); for key in [ @@ -203,7 +203,8 @@ fn deletion_and_trash_are_blocked_until_scan_finishes() -> Result<()> { ); assert_eq!( app.state.message.as_deref(), - Some("Traversal already running") + Some("Traversal already running"), + "a snapshot must match what was scanned" ); assert!(root.join("file").exists()); assert_eq!(app.traversal.tree.len(), node_count); @@ -214,13 +215,33 @@ fn deletion_and_trash_are_blocked_until_scan_finishes() -> Result<()> { assert!(app.state.scan.is_some()); } + app.state + .scan + .as_mut() + .expect("active scan") + .snapshot_export = None; + app.state.dispatch_to_mark_pane( + delete_key, + &mut app.window, + &mut TreeView { + traversal: &mut app.traversal, + scope: None, + glob_tree_root: None, + glob_matches: None, + }, + app.display, + &app.config, + ); + assert!(app.state.is_deleting(), "the scan does not block deletion"); + assert!(app.state.scan.is_some(), "deletion does not end the scan"); + let (_key_send, key_receive) = crossbeam::channel::bounded(0); app.run_until_traversed(&mut terminal, key_receive)?; - app.process_events(&mut terminal, into_events([Event::Key(delete_key)]))?; assert!( - !root.exists(), - "deletion succeeds when retried after the scan" + !app.state.is_deleting(), + "deletion finishes before the scan" ); + assert!(!root.exists()); assert!(app.window.mark.is_none()); assert_eq!(app.traversal.tree.len(), 1); Ok(()) diff --git a/src/traverse.rs b/src/traverse.rs index 89c66040..d016c08f 100644 --- a/src/traverse.rs +++ b/src/traverse.rs @@ -830,12 +830,31 @@ pub struct BackgroundTraversal { use_root_path: bool, retained_depth: Option, preexisting_nodes: HashMap, + /// Entries whose nodes were removed from the tree while this traversal was still running. + removed: RemovedNodes, /// Receiver used to obtain traversal events from the worker thread. pub event_rx: Receiver, clean_stages: HashMap, _cancelled: Option, } +/// Walker-side identities of nodes that disappeared from the tree mid-traversal. +/// +/// The walker keeps emitting descendants of such nodes, and vacant tree slots are reused, so +/// these must be dropped by identity instead of by probing the tree for a stale index. +#[derive(Default)] +struct RemovedNodes { + directories: HashSet, + roots: HashSet, + preexisting: HashSet, +} + +impl RemovedNodes { + fn is_empty(&self) -> bool { + self.directories.is_empty() && self.roots.is_empty() && self.preexisting.is_empty() + } +} + struct CleanStage { staging_root: TreeIndex, search_root: PathBuf, @@ -982,6 +1001,7 @@ impl BackgroundTraversal { use_root_path: true, retained_depth: None, preexisting_nodes: HashMap::new(), + removed: RemovedNodes::default(), event_rx, clean_stages: HashMap::new(), _cancelled: Some(CancelOnDrop(cancelled)), @@ -1145,6 +1165,7 @@ impl BackgroundTraversal { use_root_path, retained_depth: None, preexisting_nodes, + removed: RemovedNodes::default(), event_rx: entry_rx, clean_stages: HashMap::new(), _cancelled: None, @@ -1165,13 +1186,47 @@ impl BackgroundTraversal { self } + /// Stop integrating entries below `removed` nodes, which the caller is about to remove from + /// the tree, typically after deleting them from disk. `removed` must contain every removed + /// node, including descendants, and this must be called before any tree slot is reused. + /// + /// Returns `false` if the node this traversal integrates into is itself removed, in which + /// case the traversal has nothing left to update and should be dropped. + #[must_use] + pub fn forget_removed_nodes(&mut self, removed: &HashSet) -> bool { + if removed.contains(&self.root_idx) { + return false; + } + for (directory_id, node) in self.nodes_by_directory.iter_mut().enumerate() { + if node.is_some_and(|node| removed.contains(&node)) { + *node = None; + self.removed.directories.insert(directory_id); + } + } + for (root_idx, node) in self.root_nodes.iter_mut().enumerate() { + if node.is_some_and(|node| removed.contains(&node)) { + *node = None; + self.removed.roots.insert(root_idx); + } + } + let removed_paths = &mut self.removed.preexisting; + self.preexisting_nodes.retain(|path, (node, _)| { + let keep = !removed.contains(node); + if !keep { + removed_paths.insert(path.clone()); + } + keep + }); + true + } + fn record_error_on_root( &mut self, traversal: &mut Traversal, root_idx: usize, root_path: &Path, ) { - if self.skip_root { + if self.skip_root || self.removed.roots.contains(&root_idx) { return; } // Entry errors carry no descendant path, so report them on the corresponding root. @@ -1360,6 +1415,22 @@ impl BackgroundTraversal { .is_some_and(|t| t.can_update()) .then_some(false); }; + if !self.removed.is_empty() + && (entry + .parent_directory_id + .is_some_and(|id| self.removed.directories.contains(&id.index())) + || self.removed.preexisting.contains(&entry.path())) + { + // The parent was removed while its entries were still queued. + if let Some(directory_id) = entry.directory_id { + self.removed.directories.insert(directory_id.index()); + } + return self + .throttle + .as_ref() + .is_some_and(|t| t.can_update()) + .then_some(false); + } let walk_depth = entry.depth; let name = if !self.skip_root && walk_depth == 0 && self.use_root_path { root_path.as_path() @@ -2258,6 +2329,80 @@ mod tests { assert_eq!(background.stats.io_errors, 0); } + #[test] + fn entries_below_nodes_removed_during_traversal_are_dropped() { + let dir = tempfile::tempdir().unwrap(); + std::fs::create_dir_all(dir.path().join("victim/nested")).unwrap(); + std::fs::write(dir.path().join("victim/file"), b"content").unwrap(); + std::fs::write(dir.path().join("victim/nested/file"), b"content").unwrap(); + std::fs::create_dir(dir.path().join("keep")).unwrap(); + std::fs::write(dir.path().join("keep/file"), b"content").unwrap(); + + let mut traversal = Traversal::new(); + let root = traversal.root_index; + let mut background = BackgroundTraversal::start( + root, + &WalkOptions { + threads: 2, + count_hard_links: true, + apparent_size: true, + cross_filesystems: true, + ignore_dirs: std::collections::BTreeSet::default(), + ignore_patterns: None, + metadata_options: crate::TraversalOptions::default(), + base_dir: None, + }, + vec![dir.path().to_owned()], + None, + true, + false, + ) + .unwrap(); + let child = |traversal: &Traversal, parent, name: &str| { + traversal + .tree + .children(parent) + .find(|&child| traversal.tree.name(child).unwrap() == Path::new(name)) + }; + + // Entries are emitted parent-first, so those below `victim` are still queued. + let victim = loop { + let event = background.event_rx.recv().unwrap(); + assert_ne!( + background.integrate_traversal_event(&mut traversal, event), + Some(true) + ); + if let Some(victim) = child(&traversal, root, "victim") { + break victim; + } + }; + let mut removed = HashSet::new(); + let mut pending = vec![victim]; + while let Some(index) = pending.pop() { + removed.insert(index); + pending.extend(traversal.tree.children(index)); + } + assert!(background.forget_removed_nodes(&removed)); + traversal.tree.remove_subtree(victim); + + while background + .integrate_traversal_event(&mut traversal, background.event_rx.recv().unwrap()) + != Some(true) + {} + assert!(child(&traversal, root, "victim").is_none()); + let keep = child(&traversal, root, "keep").expect("unrelated entries are retained"); + assert!(child(&traversal, keep, "file").is_some()); + assert_eq!( + traversal.tree.len(), + 3, + "queued entries must not land in removed or reused nodes" + ); + assert!( + !background.forget_removed_nodes(&HashSet::from([root])), + "a traversal cannot outlive the node it integrates into" + ); + } + #[test] fn ancestor_sizes_update_before_traversal_finishes() { let dir = tempfile::tempdir().unwrap();