parex 0.1.0

Blazing-fast parallel search engine — generic, embeddable, zero opinions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::path::PathBuf;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Instant;

use crate::error::ParexError;
use crate::results::{Results, ScanStats};
use crate::traits::Matcher;

// ---------------------------------------------------------------------------
// WalkConfig
// ---------------------------------------------------------------------------

/// Traversal parameters passed from the builder to the engine and source.
///
/// Sources receive this so they can honour depth limits, thread counts,
/// and result limits during their own traversal logic.
pub struct WalkConfig {
    pub threads: usize,
    pub max_depth: Option<usize>,
    pub limit: Option<usize>,
}

// ---------------------------------------------------------------------------
// Engine options
// ---------------------------------------------------------------------------

/// Internal options passed from the builder to `run()`.
pub(crate) struct EngineOptions {
    pub config: WalkConfig,
    pub source: Box<dyn crate::traits::Source>,
    pub matcher: Arc<dyn Matcher>,
    pub collect_paths: bool,
    pub collect_errors: bool,
}

// ---------------------------------------------------------------------------
// run()
// ---------------------------------------------------------------------------

/// Execute a search using the source's iterator.
///
/// Iterates `Result<Entry, ParexError>` items from `source.walk()`.
/// `Ok` entries are matched and collected. `Err` entries are counted as
/// recoverable errors and stored in `Results::errors` when
/// `collect_errors` is enabled.
pub(crate) fn run(opts: EngineOptions) -> Results {
    let start = Instant::now();

    let entries = opts.source.walk(&opts.config);

    let matches = Arc::new(AtomicUsize::new(0));
    let files = Arc::new(AtomicUsize::new(0));
    let dirs = Arc::new(AtomicUsize::new(0));
    let paths = Arc::new(Mutex::new(Vec::<PathBuf>::new()));
    let errors = Arc::new(Mutex::new(Vec::<ParexError>::new()));

    let limit = opts.config.limit;
    let collect_paths = opts.collect_paths;
    let collect_errors = opts.collect_errors;
    let matcher = &opts.matcher;

    for item in entries {
        // Enforce limit before processing next item
        if let Some(lim) = limit {
            if matches.load(Ordering::Relaxed) >= lim {
                break;
            }
        }

        let entry = match item {
            Ok(e) => e,
            Err(err) => {
                // Recoverable error — collect if requested, keep walking
                if collect_errors && err.is_recoverable() {
                    if let Ok(mut errs) = errors.lock() {
                        errs.push(err);
                    }
                }
                continue;
            }
        };

        // Count by kind
        match entry.kind {
            crate::entry::EntryKind::Dir => {
                dirs.fetch_add(1, Ordering::Relaxed);
            }
            crate::entry::EntryKind::File => {
                files.fetch_add(1, Ordering::Relaxed);
            }
            _ => {}
        }

        if !matcher.is_match(&entry) {
            continue;
        }

        let mc = matches.fetch_add(1, Ordering::Relaxed) + 1;

        if collect_paths {
            if let Ok(mut p) = paths.lock() {
                p.push(entry.path.clone());
            }
        }

        if let Some(lim) = limit {
            if mc >= lim {
                break;
            }
        }
    }

    let duration = start.elapsed();
    let matches = matches.load(Ordering::Relaxed);
    let files = files.load(Ordering::Relaxed);
    let dirs = dirs.load(Ordering::Relaxed);
    let paths = Arc::try_unwrap(paths)
        .unwrap_or_default()
        .into_inner()
        .unwrap_or_default();
    let errors = Arc::try_unwrap(errors)
        .unwrap_or_default()
        .into_inner()
        .unwrap_or_default();

    let matches = match limit {
        Some(lim) => matches.min(lim),
        None => matches,
    };

    Results {
        matches,
        paths,
        stats: ScanStats::compute(files, dirs, duration),
        errors,
    }
}