chaud-hot 0.1.1

Implementation detail of Chaud.
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

use super::graph::{Graph, KrateDir};
use crate::util::latest::{LatestPublisher, LatestReader, make_latest};
use anyhow::{Context as _, Result, ensure};
use core::ops;
use hashbrown::HashMap;
use notify::{
    EventHandler, EventKind, RecommendedWatcher, RecursiveMode, Watcher as _, recommended_watcher,
};
use std::time::Instant;

pub struct Watcher {
    #[expect(dead_code, reason = "keep alive")]
    inner: RecommendedWatcher,
    latest: LatestReader<Instant>,
}

impl ops::Deref for Watcher {
    type Target = LatestReader<Instant>;

    fn deref(&self) -> &Self::Target {
        &self.latest
    }
}

impl ops::DerefMut for Watcher {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.latest
    }
}

impl Watcher {
    pub fn new(graph: &'static Graph) -> Result<Self> {
        new_inner(graph).context("Failed to create watcher")
    }
}

fn new_inner(graph: &'static Graph) -> Result<Watcher> {
    let (publisher, reader) = make_latest(Instant::now());

    let dirs = extract_dirs(graph)?;

    let mut inner =
        recommended_watcher(EvHandler { latest: publisher, reported_event_err: false })?;

    for dir in &dirs {
        inner.watch(dir.path().as_std_path(), dir.rec_mode())?;
        log::trace!("Watching: {:?} ({:?})", dir.path(), dir.rec_mode());
    }

    log::debug!("Watching {} paths", dirs.len());

    Ok(Watcher { inner, latest: reader })
}

impl KrateDir {
    fn rec_mode(&self) -> RecursiveMode {
        match self {
            KrateDir::Src(_) => RecursiveMode::Recursive,
            KrateDir::Root(_) => RecursiveMode::NonRecursive,
        }
    }
}

struct EvHandler {
    latest: LatestPublisher<Instant>,
    reported_event_err: bool,
}

impl EventHandler for EvHandler {
    fn handle_event(&mut self, event: notify::Result<notify::Event>) {
        let event = match event {
            Ok(ev) => ev,
            Err(err) => return self.report_event_err(&err),
        };

        match event.kind {
            EventKind::Any | EventKind::Other | EventKind::Access(_) => return,
            EventKind::Create(_) | EventKind::Modify(_) | EventKind::Remove(_) => (),
        }

        if !event.paths.is_empty() {
            self.latest.publish(Instant::now());
        }
    }
}

impl EvHandler {
    fn report_event_err(&mut self, err: &notify::Error) {
        if self.reported_event_err {
            log::trace!("Watcher error: {err}");
        } else {
            self.reported_event_err = true;
            log::warn!("Watcher error: {err}");
            log::warn!("Future Watcher errors will be logged only as TRACE");
        }
    }
}

fn extract_dirs(graph: &Graph) -> Result<Box<[&KrateDir]>> {
    let mut dirs = HashMap::new();

    for krate in graph.collect_krates_to_watch() {
        for dir in krate.dirs() {
            let path = dir.path();

            let did_insert = dirs.try_insert(path, dir).is_ok();

            ensure!(did_insert, "Duplicate crate path: {path:?}");
        }
    }

    let mut dirs: Box<[_]> = dirs.into_values().collect();
    dirs.sort_unstable_by_key(|dir| dir.path());

    Ok(dirs)
}