Skip to main content

taskfast_cli/cmd/events/
seen.rs

1// SPDX-License-Identifier: MIT
2//! Seen-event-id set for `events poll` / `events stream` (gh#204).
3//!
4//! The server delivers at least once, so the same `event_id` can arrive
5//! twice. The newest 10,000 ids live in one file next to the config
6//! (`events.seen`, one id per line, oldest first). The server retries for
7//! about 6 minutes, so 10,000 ids covers every retry with a wide margin.
8//!
9//! I/O failures never drop events: warn once on stderr, keep going with
10//! whatever is in memory (at-least-once beats losing an event).
11
12use std::collections::{HashSet, VecDeque};
13
14use crate::state_store::{StateAsset, StateStore};
15
16const CAP: usize = 10_000;
17
18pub struct SeenIds {
19    store: StateStore,
20    order: VecDeque<String>,
21    set: HashSet<String>,
22    /// Lines currently in the file; compact once it exceeds `2 * CAP`.
23    file_lines: usize,
24    quiet: bool,
25    warned: bool,
26}
27
28impl SeenIds {
29    pub fn new(store: StateStore, quiet: bool) -> Self {
30        let mut s = Self {
31            store: store.clone(),
32            order: VecDeque::new(),
33            set: HashSet::new(),
34            file_lines: 0,
35            quiet,
36            warned: false,
37        };
38        match store.load_seen_lines() {
39            Ok(lines) => {
40                for id in lines {
41                    s.remember(&id);
42                    s.file_lines += 1;
43                }
44            }
45            Err(e) => {
46                let display = store
47                    .path_for(StateAsset::EventsSeen)
48                    .map_or_else(|| "in-memory".to_string(), |p| p.display().to_string());
49                s.warn(&format!("read {display}: {e}"));
50            }
51        }
52        s
53    }
54
55    /// Check if `id` has already been seen.
56    pub fn contains(&self, id: &str) -> bool {
57        self.set.contains(id)
58    }
59
60    pub fn remember(&mut self, id: &str) {
61        if self.set.insert(id.to_string()) {
62            self.order.push_back(id.to_string());
63        }
64        while self.order.len() > CAP {
65            if let Some(old) = self.order.pop_front() {
66                self.set.remove(&old);
67            }
68        }
69    }
70
71    /// Commit a batch of seen IDs into memory and persist to StateStore.
72    pub fn commit_ids(&mut self, ids: &[String]) {
73        if ids.is_empty() {
74            return;
75        }
76
77        for id in ids {
78            self.remember(id);
79        }
80
81        let res = if self.file_lines + ids.len() >= 2 * CAP {
82            let res = self.store.rewrite_seen_lines(&self.order);
83            if res.is_ok() {
84                self.file_lines = self.order.len();
85            }
86            res
87        } else {
88            let mut write_err = Ok(());
89            for id in ids {
90                if let Err(e) = self.store.append_seen_line(id) {
91                    write_err = Err(e);
92                    break;
93                }
94                self.file_lines += 1;
95            }
96            write_err
97        };
98        if let Err(e) = res {
99            let display = self
100                .store
101                .path_for(StateAsset::EventsSeen)
102                .map_or_else(|| "in-memory".to_string(), |p| p.display().to_string());
103            self.warn(&format!("write {display}: {e}"));
104        }
105    }
106
107    fn warn(&mut self, msg: &str) {
108        if self.warned || self.quiet {
109            return;
110        }
111        self.warned = true;
112        eprintln!("warning: events seen-id file unusable ({msg}); duplicates may be printed");
113    }
114}
115
116#[cfg(test)]
117mod tests {
118    use super::*;
119
120    fn store_in(dir: &std::path::Path) -> StateStore {
121        StateStore::from_config_path(&dir.join("config.json"))
122    }
123
124    fn record_id(s: &mut SeenIds, id: &str) -> bool {
125        if s.contains(id) {
126            return false;
127        }
128        s.commit_ids(&[id.to_string()]);
129        true
130    }
131
132    #[test]
133    fn duplicate_is_dropped_and_survives_restart() {
134        let dir = tempfile::tempdir().unwrap();
135        let store = store_in(dir.path());
136        let mut a = SeenIds::new(store.clone(), true);
137        assert!(record_id(&mut a, "e1"));
138        assert!(!record_id(&mut a, "e1"));
139        let mut b = SeenIds::new(store, true);
140        assert!(!record_id(&mut b, "e1"));
141        assert!(record_id(&mut b, "e2"));
142    }
143
144    #[test]
145    fn keeps_only_newest_cap_ids() {
146        let dir = tempfile::tempdir().unwrap();
147        let store = store_in(dir.path());
148        let mut s = SeenIds::new(store.clone(), true);
149        for i in 0..CAP + 5 {
150            assert!(record_id(&mut s, &format!("id{i}")));
151        }
152        assert!(record_id(&mut s, "id0"), "oldest evicted");
153        assert!(!record_id(&mut s, &format!("id{}", CAP + 4)));
154        assert!(SeenIds::new(store, true).set.len() <= CAP);
155    }
156
157    #[test]
158    fn unwritable_file_warns_once_and_still_reports_first_time() {
159        let dir = tempfile::tempdir().unwrap();
160        let store = store_in(dir.path());
161        // A directory where the file should be makes read and write fail.
162        std::fs::create_dir(dir.path().join(StateAsset::EventsSeen.filename())).unwrap();
163        let mut s = SeenIds::new(store, true);
164        assert!(s.warned || s.quiet);
165        assert!(record_id(&mut s, "e1"));
166        assert!(!record_id(&mut s, "e1"));
167    }
168}