Skip to main content

cleaner_core/
scanner.rs

1//! Parallel directory scanner using jwalk
2//! Configured for maximum performance with rayon thread pool
3
4use 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/// Result of scanning - a path to delete and whether it's a directory
61#[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
75/// Parallel directory scanner
76pub 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    /// Scan directory and send matching paths to channel
103    /// Returns total number of entries scanned
104    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        // macOS Docker exclusion: sparse disk image reports wrong sizes
114        #[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        // Protected directories (NEVER auto-clean inside these, but allow scanning)
132        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    // Spawn sub-tasks in parallel using rayon work-stealing
270    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}