Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 21 additions & 1 deletion src/interactive/app/deletion_progress.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down Expand Up @@ -243,6 +249,7 @@ impl AppState {

let mut deltas = HashMap::<TreeIndex, (u128, u64)>::new();
let mut parents = HashMap::<TreeIndex, HashSet<TreeIndex>>::new();
let mut removed_nodes = HashSet::new();
for &index in &roots {
let Some(data) = tree.tree().data(index) else {
continue;
Expand All @@ -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))
Comment thread
Byron marked this conversation as resolved.
Resolved
{
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;
Expand Down
35 changes: 28 additions & 7 deletions src/interactive/app/tests/journeys_with_writes.rs
Original file line number Diff line number Diff line change
@@ -1,9 +1,9 @@
use crate::interactive::app::tests::utils::{
WritableFixture, initialized_app_and_terminal_from_paths, into_codes, into_events,

Check warning on line 2 in src/interactive/app/tests/journeys_with_writes.rs

View workflow job for this annotation

GitHub Actions / Windows (nightly)

unused import: `WritableFixture`

Check warning on line 2 in src/interactive/app/tests/journeys_with_writes.rs

View workflow job for this annotation

GitHub Actions / Windows (nightly)

unused import: `WritableFixture`
new_test_terminal,
};
use crate::interactive::terminal::TerminalApp;
use crate::interactive::widgets::Language;

Check warning on line 6 in src/interactive/app/tests/journeys_with_writes.rs

View workflow job for this annotation

GitHub Actions / Windows (nightly)

unused import: `crate::interactive::widgets::Language`

Check warning on line 6 in src/interactive/app/tests/journeys_with_writes.rs

View workflow job for this annotation

GitHub Actions / Windows (nightly)

unused import: `crate::interactive::widgets::Language`
use anyhow::Result;
use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
use dua::{ByteFormat, Config, WalkOptions};
Expand Down Expand Up @@ -149,14 +149,14 @@
}

#[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(
Expand All @@ -181,7 +181,7 @@
)?,
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 [
Expand All @@ -203,7 +203,8 @@
);
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);
Expand All @@ -214,13 +215,33 @@
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(())
Expand Down
147 changes: 146 additions & 1 deletion src/traverse.rs
Original file line number Diff line number Diff line change
Expand Up @@ -830,12 +830,31 @@ pub struct BackgroundTraversal {
use_root_path: bool,
retained_depth: Option<usize>,
preexisting_nodes: HashMap<PathBuf, (TreeIndex, bool)>,
/// 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<TraversalEvent>,
clean_stages: HashMap<usize, CleanStage>,
_cancelled: Option<CancelOnDrop>,
}

/// 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<usize>,
roots: HashSet<usize>,
preexisting: HashSet<PathBuf>,
}

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,
Expand Down Expand Up @@ -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)),
Expand Down Expand Up @@ -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,
Expand All @@ -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<TreeIndex>) -> 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.
Expand Down Expand Up @@ -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()
Expand Down Expand Up @@ -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();
Expand Down
Loading