1use crate::config::Config;
5use crate::fastwalk;
6use crate::patterns::PatternMatcher;
7#[cfg(test)]
8use crate::pool::build_worker_pool;
9use crate::protected::protected_paths_for_root;
10use crossbeam_channel::Sender;
11use rayon::ThreadPool;
12#[allow(unused_imports)]
13use std::path::{Path, PathBuf};
14use std::sync::atomic::AtomicBool;
15use std::sync::atomic::Ordering;
16use std::sync::Arc;
17
18fn passes_age_filter(path: &Path, days: Option<u64>) -> bool {
19 let Some(days) = days else { return true };
20 std::fs::metadata(path)
21 .and_then(|metadata| metadata.modified())
22 .ok()
23 .and_then(|modified| modified.elapsed().ok())
24 .is_some_and(|elapsed| elapsed.as_secs() > days.saturating_mul(24 * 60 * 60))
25}
26
27fn matched_file_size(path: &Path, days: Option<u64>) -> Option<u64> {
28 let metadata = std::fs::metadata(path);
29 let Some(days) = days else {
30 return Some(
31 metadata
32 .map(|value| {
33 #[cfg(unix)]
34 {
35 use std::os::unix::fs::MetadataExt;
36 std::cmp::min(value.len(), value.blocks() * 512)
37 }
38 #[cfg(not(unix))]
39 value.len()
40 })
41 .unwrap_or(0),
42 );
43 };
44
45 let metadata = metadata.ok()?;
46 let modified = metadata.modified().ok()?;
47 let elapsed = modified.elapsed().ok()?;
48 let size = {
49 #[cfg(unix)]
50 {
51 use std::os::unix::fs::MetadataExt;
52 std::cmp::min(metadata.len(), metadata.blocks() * 512)
53 }
54 #[cfg(not(unix))]
55 metadata.len()
56 };
57 (elapsed.as_secs() > days.saturating_mul(24 * 60 * 60)).then_some(size)
58}
59
60#[derive(Debug, Clone)]
62pub struct ScanResult {
63 pub path: PathBuf,
64 pub is_dir: bool,
65 pub size: u64,
66}
67
68#[derive(Debug, Clone, Copy, PartialEq, Eq)]
69pub struct ScanSummary {
70 pub entries: usize,
71 pub errors: usize,
72 pub receiver_closed: bool,
73}
74
75pub struct Scanner {
77 matcher: PatternMatcher,
78 config: Arc<Config>,
79 root: PathBuf,
80 pool: Arc<ThreadPool>,
81}
82
83impl Scanner {
84 #[cfg(test)]
85 pub fn new(root: PathBuf, num_threads: usize, config: Arc<Config>) -> Self {
86 Self::with_pool(
87 root,
88 build_worker_pool(num_threads, "cleaner-worker"),
89 config,
90 )
91 }
92
93 pub fn with_pool(root: PathBuf, pool: Arc<ThreadPool>, config: Arc<Config>) -> Self {
94 Self {
95 matcher: PatternMatcher::new(Arc::clone(&config)),
96 config,
97 root,
98 pool,
99 }
100 }
101
102 pub fn scan(&self, tx: Sender<ScanResult>) -> ScanSummary {
105 self.scan_with_cancel(tx, &AtomicBool::new(false))
106 }
107
108 pub fn scan_with_cancel(&self, tx: Sender<ScanResult>, cancelled: &AtomicBool) -> ScanSummary {
109 let scanned = std::sync::atomic::AtomicUsize::new(0);
110 let errors = std::sync::atomic::AtomicUsize::new(0);
111 let receiver_closed = AtomicBool::new(false);
112
113 #[cfg(target_os = "macos")]
115 let docker_path: Option<PathBuf> = {
116 if let Some(home) = std::env::var_os("HOME") {
117 let docker_container =
118 PathBuf::from(home).join("Library/Containers/com.docker.docker");
119 if docker_container.exists() {
120 Some(docker_container)
121 } else {
122 None
123 }
124 } else {
125 None
126 }
127 };
128 #[cfg(not(target_os = "macos"))]
129 let docker_path: Option<PathBuf> = None;
130
131 let protected_paths = protected_paths_for_root(&self.root, self.config.force);
133
134 let context = ScanContext {
135 matcher: &self.matcher,
136 config: &self.config,
137 tx: &tx,
138 scanned: &scanned,
139 docker_path: &docker_path,
140 protected_paths: &protected_paths,
141 #[cfg(target_os = "macos")]
142 root: &self.root,
143 cancelled,
144 errors: &errors,
145 receiver_closed: &receiver_closed,
146 };
147
148 self.pool.scope(|s| {
149 walk_scanner(s, self.root.clone(), false, &context);
150 });
151
152 ScanSummary {
153 entries: scanned.into_inner(),
154 errors: errors.into_inner(),
155 receiver_closed: receiver_closed.into_inner(),
156 }
157 }
158}
159
160struct ScanContext<'a> {
161 matcher: &'a PatternMatcher,
162 config: &'a Config,
163 tx: &'a Sender<ScanResult>,
164 scanned: &'a std::sync::atomic::AtomicUsize,
165 docker_path: &'a Option<PathBuf>,
166 protected_paths: &'a [PathBuf],
167 #[cfg(target_os = "macos")]
168 root: &'a Path,
169 cancelled: &'a AtomicBool,
170 errors: &'a std::sync::atomic::AtomicUsize,
171 receiver_closed: &'a AtomicBool,
172}
173
174fn walk_scanner<'scope>(
175 scope: &rayon::Scope<'scope>,
176 dir: PathBuf,
177 in_protected_dir: bool,
178 context: &'scope ScanContext<'scope>,
179) {
180 if context.cancelled.load(Ordering::Relaxed) {
181 return;
182 }
183 let entries = match fastwalk::read_dir_types(&dir) {
184 Ok(e) => e,
185 Err(_) => {
186 context.errors.fetch_add(1, Ordering::Relaxed);
187 return;
188 }
189 };
190 context.scanned.fetch_add(entries.len(), Ordering::Relaxed);
191
192 let mut subdirs = Vec::with_capacity(8);
193
194 for e in entries {
195 if context.cancelled.load(Ordering::Relaxed) {
196 return;
197 }
198 if e.is_dir {
199 let path = dir.join(&e.name);
200 if context
201 .docker_path
202 .as_ref()
203 .is_some_and(|docker| path.starts_with(docker))
204 {
205 continue;
206 }
207
208 #[cfg(target_os = "macos")]
209 {
210 if path.starts_with("/System/Volumes")
211 && !context.root.starts_with("/System/Volumes")
212 {
213 continue;
214 }
215 if path.starts_with("/Volumes") && !context.root.starts_with("/Volumes") {
216 continue;
217 }
218 }
219
220 let in_protected = in_protected_dir
221 || context
222 .protected_paths
223 .iter()
224 .any(|protected| path.starts_with(protected));
225 if !in_protected && context.matcher.is_temp_directory(&e.name) {
226 let should_delete = passes_age_filter(&path, context.config.days);
227
228 if should_delete {
229 if context
230 .tx
231 .send(ScanResult {
232 path,
233 is_dir: true,
234 size: 0,
235 })
236 .is_err()
237 {
238 context.receiver_closed.store(true, Ordering::Relaxed);
239 context.cancelled.store(true, Ordering::Relaxed);
240 return;
241 }
242 continue;
243 }
244 }
245
246 if !e.is_symlink {
247 subdirs.push((path, in_protected));
248 }
249 } else if !in_protected_dir && context.matcher.is_temp_file(&e.name) {
250 let path = dir.join(&e.name);
251 if let Some(size) = matched_file_size(&path, context.config.days) {
252 if context
253 .tx
254 .send(ScanResult {
255 path,
256 is_dir: false,
257 size,
258 })
259 .is_err()
260 {
261 context.receiver_closed.store(true, Ordering::Relaxed);
262 context.cancelled.store(true, Ordering::Relaxed);
263 return;
264 }
265 }
266 }
267 }
268
269 for (subdir, protected) in subdirs {
271 scope.spawn(move |s| {
272 walk_scanner(s, subdir, protected, context);
273 });
274 }
275}
276
277#[cfg(test)]
278mod tests {
279 use super::*;
280 use crate::test_support::TempDir;
281 use crossbeam_channel::unbounded;
282
283 fn config(days: Option<u64>) -> Arc<Config> {
284 Arc::new(Config {
285 directories: vec!["target".into()],
286 files: vec![".pyc".into()],
287 days,
288 force: false,
289 })
290 }
291
292 #[test]
293 fn scanner_finds_files_and_prunes_matched_directories() {
294 let temp = TempDir::new("scanner-match");
295 temp.write("module.pyc", b"1234");
296 temp.write("source.rs", b"keep");
297 temp.write("nested/other.pyc", b"12");
298 temp.write("target/inside.pyc", b"not scanned after directory match");
299 let (tx, rx) = unbounded();
300 let scanned = Scanner::new(temp.path().to_path_buf(), 2, config(None)).scan(tx);
301 let mut results: Vec<_> = rx.iter().collect();
302 results.sort_by(|a, b| a.path.cmp(&b.path));
303 assert_eq!(results.len(), 3);
304 assert!(results
305 .iter()
306 .any(|r| r.path == temp.join("module.pyc") && !r.is_dir && r.size == 4));
307 assert!(results
308 .iter()
309 .any(|r| r.path == temp.join("nested/other.pyc") && !r.is_dir));
310 assert!(results
311 .iter()
312 .any(|r| r.path == temp.join("target") && r.is_dir));
313 assert_eq!(scanned.entries, 5);
314 assert_eq!(scanned.errors, 0);
315 }
316
317 #[test]
318 fn scanner_uses_requested_thread_count() {
319 let temp = TempDir::new("scanner-threads");
320 let scanner = Scanner::new(temp.path().to_path_buf(), 3, config(None));
321 assert_eq!(scanner.pool.current_num_threads(), 3);
322 }
323
324 #[test]
325 fn scanner_reports_read_and_receiver_errors() {
326 let temp = TempDir::new("scanner-errors");
327 let (tx, rx) = unbounded();
328 drop(rx);
329 temp.write("match.pyc", b"data");
330 let summary = Scanner::new(temp.path().to_path_buf(), 1, config(None)).scan(tx);
331 assert!(summary.receiver_closed);
332
333 let (tx, _rx) = unbounded();
334 let summary = Scanner::new(temp.join("missing"), 1, config(None)).scan(tx);
335 assert_eq!(summary.errors, 1);
336 }
337
338 #[cfg(unix)]
339 #[test]
340 fn scanner_traverses_non_utf8_directories() {
341 use std::os::unix::ffi::OsStringExt;
342 let temp = TempDir::new("scanner-non-utf8");
343 let directory = temp
344 .path()
345 .join(std::ffi::OsString::from_vec(b"dir-\xff".to_vec()));
346 if std::fs::create_dir(&directory).is_err() {
347 return;
348 }
349 if std::fs::write(directory.join("inside.pyc"), b"123").is_err() {
350 return;
351 }
352 let (tx, rx) = unbounded();
353 let summary = Scanner::new(temp.path().to_path_buf(), 1, config(None)).scan(tx);
354 assert_eq!(summary.errors, 0);
355 assert!(rx.iter().any(|result| result.path.ends_with("inside.pyc")));
356 }
357
358 #[test]
359 fn age_filter_keeps_recent_items_and_handles_huge_values() {
360 let temp = TempDir::new("scanner-age");
361 let file = temp.write("recent.pyc", b"data");
362 assert!(passes_age_filter(&file, None));
363 assert!(!passes_age_filter(&file, Some(u64::MAX)));
364 assert!(!passes_age_filter(&temp.join("missing"), Some(1)));
365
366 let (tx, rx) = unbounded();
367 Scanner::new(temp.path().to_path_buf(), 1, config(Some(u64::MAX))).scan(tx);
368 assert!(rx.iter().next().is_none());
369 }
370
371 #[cfg(unix)]
372 #[test]
373 fn scanner_does_not_follow_directory_symlinks() {
374 use std::os::unix::fs::symlink;
375 let temp = TempDir::new("scanner-link");
376 temp.write("outside/file.pyc", b"data");
377 symlink(temp.join("outside"), temp.join("linked-dir")).unwrap();
378 let (tx, rx) = unbounded();
379 Scanner::new(temp.path().to_path_buf(), 1, config(None)).scan(tx);
380 let results: Vec<_> = rx.iter().collect();
381 assert_eq!(
382 results
383 .iter()
384 .filter(|r| r.path.ends_with("file.pyc"))
385 .count(),
386 1
387 );
388 }
389}