Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_mail/tests/maildir_integrity.rs

20.2 KiB, 27 runs

created by r1870400018:74756, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! The Maildir store's UID bookkeeping under concurrency and damage.
2//!
3//! Steel's IMAP sessions and its SMTP delivery all read, change and write one
4//! `dovecot-uidlist` per folder. A UID that is renumbered or swapped without a
5//! change of UIDVALIDITY makes every UID-keyed client act on the wrong message,
6//! so these tests hold the store to RFC 3501 §2.3.1.1: a UID names one message
7//! for as long as the UIDVALIDITY lasts, and UIDNEXT never moves backwards.
8
9use oxedyne_fe2o3_core::{
10 prelude::*,
11 file::ExclusiveLock,
12};
13use oxedyne_fe2o3_mail::maildir::MaildirStore;
14use oxedyne_fe2o3_net::mail::store::{
15 FlagUpdate,
16 FolderName,
17 MailStore,
18 MailUser,
19 MessageFlags,
20 MessageUid,
21};
22
23use std::{
24 collections::BTreeMap,
25 fs,
26 path::{
27 Path,
28 PathBuf,
29 },
30 process::Command,
31 sync::{
32 Arc,
33 Mutex,
34 },
35 thread,
36 time::{
37 Duration,
38 Instant,
39 },
40};
41
42
43const CHILD_ENV: &str = "FE2O3_MAILDIR_CHILD_ROOT"; // set only in a spawned writer process
44const CHILD_TAG: &str = "FE2O3_MAILDIR_CHILD_TAG";
45const WRITERS: usize = 4;
46const PER_WRITER: usize = 20;
47const READERS: usize = 3;
48const CHILD_PROCS: usize = 2;
49
50fn user() -> MailUser {
51 MailUser {
52 local: fmt!("alice"),
53 domain: fmt!("test.local"),
54 delivery_key: fmt!("test.local/alice"),
55 send_as: Vec::new(),
56 }
57}
58
59fn fresh_root(name: &str) -> Outcome<PathBuf> {
60 let root = std::env::temp_dir().join(fmt!("fe2o3_maildir_{}_{}", name, std::process::id()));
61 let _ = fs::remove_dir_all(&root);
62 res!(fs::create_dir_all(&root), IO, File);
63 Ok(root)
64}
65
66fn inbox_dir(root: &Path) -> PathBuf {
67 root.join("test.local").join("alice")
68}
69
70fn body(tag: &str) -> Vec<u8> {
71 fmt!("From: bob@example.org\r\nTo: alice@test.local\r\nSubject: {}\r\n\r\nid={}\r\n",
72 tag, tag).into_bytes()
73}
74
75/// The `id=` tag a message carries, which names it independently of its UID.
76fn tag_of(bytes: &[u8]) -> String {
77 let s = String::from_utf8_lossy(bytes);
78 match s.find("id=") {
79 Some(i) => s[i + 3..].trim().to_string(),
80 None => String::new(),
81 }
82}
83
84/// UID → tag for every message in the folder now.
85fn uid_map(store: &MaildirStore, u: &MailUser, f: &FolderName) -> Outcome<BTreeMap<u32, String>> {
86 let msgs = res!(store.list_messages(u, f, true));
87 let mut out = BTreeMap::new();
88 for m in &msgs {
89 if let Some(bytes) = res!(store.fetch_bytes(u, f, m.uid)) {
90 out.insert(m.uid.0, tag_of(&bytes));
91 }
92 }
93 Ok(out)
94}
95
96fn is_root() -> bool {
97 match fs::read_to_string("/proc/self/status") {
98 Ok(s) => s.lines().any(|l| l.starts_with("Uid:")
99 && l.split_whitespace().nth(2) == Some("0")),
100 Err(_) => false,
101 }
102}
103
104#[cfg(unix)]
105fn set_mode(p: &Path, mode: u32) -> Outcome<()> {
106 use std::os::unix::fs::PermissionsExt;
107 res!(fs::set_permissions(p, fs::Permissions::from_mode(mode)), IO, File);
108 Ok(())
109}
110
111/// Not a test of its own: the body of a writer process spawned by
112/// `concurrent_appends_and_reads_agree_on_every_uid`, a no-op otherwise.
113#[test]
114fn child_appender() -> Outcome<()> {
115 let root = match std::env::var(CHILD_ENV) {
116 Ok(r) => PathBuf::from(r),
117 Err(_) => return Ok(()),
118 };
119 let tag = res!(std::env::var(CHILD_TAG), Missing);
120 let store = res!(MaildirStore::new(root, "test.local"));
121 let u = user();
122 let inbox = FolderName::new("INBOX");
123 for i in 0..PER_WRITER {
124 res!(store.append(&u, &inbox, &body(&fmt!("{}-{}", tag, i)), MessageFlags::default(), None));
125 }
126 Ok(())
127}
128
129#[test]
130fn concurrent_appends_and_reads_agree_on_every_uid() -> Outcome<()> {
131 let root = res!(fresh_root("concurrent"));
132 let store = res!(MaildirStore::new(root.clone(), "test.local"));
133 let u = user();
134 res!(store.ensure_user(&u));
135 let inbox = FolderName::new("INBOX");
136
137 // Writer processes, so the lock is proved across processes too.
138 let exe = res!(std::env::current_exe(), IO, File);
139 let mut children = Vec::new();
140 for p in 0..CHILD_PROCS {
141 let child = res!(Command::new(&exe)
142 .args(["--exact", "child_appender", "--test-threads=1", "--quiet"])
143 .env(CHILD_ENV, &root)
144 .env(CHILD_TAG, fmt!("p{}", p))
145 .spawn(), IO);
146 children.push(child);
147 }
148
149 let errors: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
150 let seen: Arc<Mutex<Vec<BTreeMap<u32, String>>>> = Arc::new(Mutex::new(Vec::new()));
151 let mut handles = Vec::new();
152 for t in 0..WRITERS {
153 let (store, u, inbox, errors) = (store.clone(), u.clone(), inbox.clone(), errors.clone());
154 handles.push(thread::spawn(move || {
155 for i in 0..PER_WRITER {
156 if let Err(e) = store.append(&u, &inbox, &body(&fmt!("t{}-{}", t, i)),
157 MessageFlags::default(), None)
158 {
159 if let Ok(mut v) = errors.lock() { v.push(fmt!("append: {}", e)); }
160 }
161 }
162 }));
163 }
164 for _ in 0..READERS {
165 let (store, u, inbox, errors, seen) =
166 (store.clone(), u.clone(), inbox.clone(), errors.clone(), seen.clone());
167 handles.push(thread::spawn(move || {
168 let mut last_next = 0u32;
169 let mut last_validity = None;
170 for _ in 0..PER_WRITER {
171 match store.folder_status(&u, &inbox) {
172 Ok(st) => {
173 if st.uid_next < last_next {
174 if let Ok(mut v) = errors.lock() {
175 v.push(fmt!("UIDNEXT fell from {} to {}", last_next, st.uid_next));
176 }
177 }
178 last_next = st.uid_next;
179 if let Some(old) = last_validity {
180 if old != st.uid_validity {
181 if let Ok(mut v) = errors.lock() {
182 v.push(fmt!("UIDVALIDITY moved {} -> {}", old, st.uid_validity));
183 }
184 }
185 }
186 last_validity = Some(st.uid_validity);
187 },
188 Err(e) => if let Ok(mut v) = errors.lock() { v.push(fmt!("status: {}", e)); },
189 }
190 match uid_map(&store, &u, &inbox) {
191 Ok(m) => if let Ok(mut v) = seen.lock() { v.push(m); },
192 Err(e) => if let Ok(mut v) = errors.lock() { v.push(fmt!("read: {}", e)); },
193 }
194 }
195 }));
196 }
197 for h in handles {
198 if h.join().is_err() {
199 return Err(err!("A test thread panicked."; Test, Bug));
200 }
201 }
202 for mut c in children {
203 let st = res!(c.wait(), IO);
204 assert!(st.success(), "a writer process failed: {:?}", st);
205 }
206
207 let errors = res!(errors.lock().map_err(|_| err!("poisoned"; Lock))).clone();
208 assert!(errors.is_empty(), "errors under concurrency: {:?}", errors);
209
210 let fin = res!(uid_map(&store, &u, &inbox));
211 let total = (WRITERS + CHILD_PROCS) * PER_WRITER;
212 assert_eq!(fin.len(), total, "the folder holds {} of {} messages", fin.len(), total);
213 let mut by_tag: BTreeMap<String, u32> = BTreeMap::new();
214 for (uid, tag) in &fin {
215 if let Some(other) = by_tag.insert(tag.clone(), *uid) {
216 panic!("message {} holds two UIDs, {} and {}", tag, other, uid);
217 }
218 }
219 // Every reader's view of every UID is the final one.
220 let seen = res!(seen.lock().map_err(|_| err!("poisoned"; Lock))).clone();
221 for snap in &seen {
222 for (uid, tag) in snap {
223 assert_eq!(fin.get(uid), Some(tag),
224 "a reader saw UID {} as {}, but it is now {:?}", uid, tag, fin.get(uid));
225 }
226 }
227 let _ = fs::remove_dir_all(&root);
228 Ok(())
229}
230
231#[test]
232fn append_returns_the_uid_of_its_own_message() -> Outcome<()> {
233 let root = res!(fresh_root("append_uid"));
234 let store = res!(MaildirStore::new(root.clone(), "test.local"));
235 let u = user();
236 res!(store.ensure_user(&u));
237 let inbox = FolderName::new("INBOX");
238 for i in 0..3 {
239 let tag = fmt!("m{}", i);
240 let uid = res!(store.append(&u, &inbox, &body(&tag), MessageFlags::default(), None));
241 let got = res!(res!(store.fetch_bytes(&u, &inbox, uid))
242 .ok_or_else(|| err!("UID {} is missing.", uid.0; Missing)));
243 assert_eq!(tag_of(&got), tag, "append returned UID {} which is not its own message", uid.0);
244 }
245 let _ = fs::remove_dir_all(&root);
246 Ok(())
247}
248
249fn garbled_uidlist_changes_uidvalidity(damage: &[u8]) -> Outcome<()> {
250 let root = res!(fresh_root(&fmt!("garbled_{}", damage.len())));
251 let store = res!(MaildirStore::new(root.clone(), "test.local"));
252 let u = user();
253 res!(store.ensure_user(&u));
254 let inbox = FolderName::new("INBOX");
255 for i in 0..3 {
256 res!(store.append(&u, &inbox, &body(&fmt!("g{}", i)), MessageFlags::default(), None));
257 }
258 let before = res!(store.folder_status(&u, &inbox));
259 let map_before = res!(uid_map(&store, &u, &inbox));
260
261 res!(fs::write(inbox_dir(&root).join("dovecot-uidlist"), damage), IO, File);
262 res!(store.append(&u, &inbox, &body("g3"), MessageFlags::default(), None));
263
264 let after = res!(store.folder_status(&u, &inbox));
265 let map_after = res!(uid_map(&store, &u, &inbox));
266 if after.uid_validity == before.uid_validity {
267 // Under the old validity, no UID may name another message.
268 for (uid, tag) in &map_after {
269 if let Some(old) = map_before.get(uid) {
270 assert_eq!(old, tag,
271 "UID {} was {} and is now {} under the same UIDVALIDITY {}",
272 uid, old, tag, after.uid_validity);
273 }
274 }
275 panic!("a damaged uidlist {:?} left UIDVALIDITY at {} (before {:?}, after {:?})",
276 String::from_utf8_lossy(damage), after.uid_validity, map_before, map_after);
277 }
278 assert!(after.uid_validity > before.uid_validity,
279 "UIDVALIDITY went from {} to {}, not upwards", before.uid_validity, after.uid_validity);
280 assert_eq!(map_after.len(), 4);
281 let _ = fs::remove_dir_all(&root);
282 Ok(())
283}
284
285#[test]
286fn a_truncated_uidlist_changes_uidvalidity() -> Outcome<()> {
287 garbled_uidlist_changes_uidvalidity(b"")
288}
289
290#[test]
291fn a_garbled_uidlist_changes_uidvalidity() -> Outcome<()> {
292 garbled_uidlist_changes_uidvalidity(b"3 V0 N\x00\x00\nnot a line\n")
293}
294
295#[test]
296fn a_missing_uidlist_changes_uidvalidity() -> Outcome<()> {
297 let root = res!(fresh_root("missing"));
298 let store = res!(MaildirStore::new(root.clone(), "test.local"));
299 let u = user();
300 res!(store.ensure_user(&u));
301 let inbox = FolderName::new("INBOX");
302 for i in 0..2 {
303 res!(store.append(&u, &inbox, &body(&fmt!("x{}", i)), MessageFlags::default(), None));
304 }
305 let before = res!(store.folder_status(&u, &inbox));
306 res!(fs::remove_file(inbox_dir(&root).join("dovecot-uidlist")), IO, File);
307 let after = res!(store.folder_status(&u, &inbox));
308 assert!(after.uid_validity > before.uid_validity,
309 "a lost uidlist kept UIDVALIDITY {} -> {}", before.uid_validity, after.uid_validity);
310 let _ = fs::remove_dir_all(&root);
311 Ok(())
312}
313
314/// The `dovecot-uidvalidity.<hex>` markers in a folder.
315fn markers(dir: &Path) -> Outcome<Vec<String>> {
316 let mut out = Vec::new();
317 for e in res!(fs::read_dir(dir), IO, File) {
318 let name = res!(e, IO, File).file_name().to_string_lossy().into_owned();
319 if name.starts_with("dovecot-uidvalidity.") { out.push(name); }
320 }
321 out.sort();
322 Ok(out)
323}
324
325/// The Dovecot layout, one marker per folder: the pre-F2a binary reads the first marker
326/// `read_dir` returns, so an older one left beside the new would take UIDVALIDITY backwards.
327/// Removing the uidlist with Steel stopped is also the deploy's one-shot bump, so the
328/// messages must come back numbered afresh in delivery order.
329#[test]
330fn a_uidvalidity_bump_leaves_one_marker_and_numbers_afresh() -> Outcome<()> {
331 let root = res!(fresh_root("one_marker"));
332 let store = res!(MaildirStore::new(root.clone(), "test.local"));
333 let u = user();
334 res!(store.ensure_user(&u));
335 let inbox = FolderName::new("INBOX");
336 for i in 0..3 {
337 res!(store.append(&u, &inbox, &body(&fmt!("b{}", i)), MessageFlags::default(), None));
338 }
339 let dir = inbox_dir(&root);
340 let mut last = res!(store.folder_status(&u, &inbox)).uid_validity;
341 for round in 0..2 {
342 res!(fs::remove_file(dir.join("dovecot-uidlist")), IO, File);
343 let st = res!(store.folder_status(&u, &inbox));
344 assert!(st.uid_validity > last, "round {}: UIDVALIDITY {} -> {}", round, last, st.uid_validity);
345 last = st.uid_validity;
346 let want = vec![fmt!("dovecot-uidvalidity.{:08x}", st.uid_validity)];
347 assert_eq!(res!(markers(&dir)), want, "round {}: markers after a bump", round);
348 let map = res!(uid_map(&store, &u, &inbox));
349 let got: Vec<(u32, String)> = map.into_iter().collect();
350 assert_eq!(got, vec![(1, fmt!("b0")), (2, fmt!("b1")), (3, fmt!("b2"))],
351 "round {}: UIDs after a bump", round);
352 }
353 let _ = fs::remove_dir_all(&root);
354 Ok(())
355}
356
357#[cfg(unix)]
358#[test]
359fn a_failed_uidlist_write_is_an_error() -> Outcome<()> {
360 if is_root() { return Ok(()); }
361 let root = res!(fresh_root("write_fail"));
362 let store = res!(MaildirStore::new(root.clone(), "test.local"));
363 let u = user();
364 res!(store.ensure_user(&u));
365 let inbox = FolderName::new("INBOX");
366 res!(store.append(&u, &inbox, &body("w0"), MessageFlags::default(), None));
367 res!(store.folder_status(&u, &inbox));
368
369 // A message arrives that the uidlist does not yet name, and the folder
370 // directory, where the uidlist is rewritten, refuses the write.
371 let dir = inbox_dir(&root);
372 res!(fs::write(dir.join("cur").join("1.M1P1.elsewhere:2,"), body("w1")), IO, File);
373 res!(set_mode(&dir, 0o555));
374 let outcome = store.list_messages(&u, &inbox, true);
375 res!(set_mode(&dir, 0o755));
376 assert!(outcome.is_err(), "a uidlist that could not be written was reported as fine: {:?}",
377 outcome.map(|v| v.len()));
378 let _ = fs::remove_dir_all(&root);
379 Ok(())
380}
381
382#[cfg(unix)]
383#[test]
384fn expunge_reports_only_what_it_removed() -> Outcome<()> {
385 if is_root() { return Ok(()); }
386 let root = res!(fresh_root("expunge"));
387 let store = res!(MaildirStore::new(root.clone(), "test.local"));
388 let u = user();
389 res!(store.ensure_user(&u));
390 let inbox = FolderName::new("INBOX");
391 let mut uids: Vec<MessageUid> = Vec::new();
392 for i in 0..2 {
393 uids.push(res!(store.append(&u, &inbox, &body(&fmt!("e{}", i)), MessageFlags::default(), None)));
394 }
395 let del = FlagUpdate::Add(MessageFlags { deleted: true, ..MessageFlags::default() });
396 for uid in &uids {
397 res!(store.update_flags(&u, &inbox, *uid, del));
398 }
399 let cur = inbox_dir(&root).join("cur");
400 res!(set_mode(&cur, 0o555));
401 let outcome = store.expunge(&u, &inbox, None);
402 res!(set_mode(&cur, 0o755));
403 let removed = res!(outcome);
404 assert!(removed.is_empty(), "expunge reported {:?}, but no file could be removed", removed);
405 assert_eq!(res!(store.list_messages(&u, &inbox, true)).len(), 2);
406 let _ = fs::remove_dir_all(&root);
407 Ok(())
408}
409
410/// Two clients subscribing at once each read, add and save the whole list; without the
411/// user's lock one of them saves a list lacking the other's name.
412#[test]
413fn concurrent_subscribes_keep_every_name() -> Outcome<()> {
414 let root = res!(fresh_root("subscribe"));
415 let store = res!(MaildirStore::new(root.clone(), "test.local"));
416 let u = user();
417 res!(store.ensure_user(&u));
418 let threads = 8;
419 let each = 25;
420 let mut handles = Vec::new();
421 for t in 0..threads {
422 let (store, u) = (store.clone(), u.clone());
423 handles.push(thread::spawn(move || -> Outcome<()> {
424 for i in 0..each {
425 res!(store.subscribe(&u, &FolderName::new(fmt!("F{}_{}", t, i))));
426 }
427 Ok(())
428 }));
429 }
430 for h in handles {
431 match h.join() {
432 Ok(r) => res!(r),
433 Err(_) => return Err(err!("A subscribing thread panicked."; Test, Bug)),
434 }
435 }
436 let subs = res!(store.list_subscribed(&u));
437 let mut missing = Vec::new();
438 for t in 0..threads {
439 for i in 0..each {
440 let name = fmt!("F{}_{}", t, i);
441 if !subs.iter().any(|f| f.as_str() == name) { missing.push(name); }
442 }
443 }
444 assert!(missing.is_empty(), "{} of {} subscriptions lost: {:?}",
445 missing.len(), threads * each, missing);
446 let _ = fs::remove_dir_all(&root);
447 Ok(())
448}
449
450/// A holder that never lets go of a folder must show up as an error, not as every session
451/// and delivery on the folder hanging.
452#[test]
453fn a_held_folder_lock_fails_loudly_after_the_wait() -> Outcome<()> {
454 let root = res!(fresh_root("lock_wait"));
455 let store = res!(MaildirStore::new(root.clone(), "test.local"))
456 .with_lock_wait(Duration::from_millis(300));
457 let u = user();
458 res!(store.ensure_user(&u));
459 let inbox = FolderName::new("INBOX");
460 let held = res!(ExclusiveLock::acquire(&inbox_dir(&root).join("hematite-folder.lock")));
461 let t0 = Instant::now();
462 let outcome = store.folder_status(&u, &inbox);
463 let took = t0.elapsed();
464 drop(held);
465 match outcome {
466 Ok(_) => panic!("folder_status succeeded while another held the folder's lock"),
467 Err(e) => {
468 assert!(e.tags().contains(&ErrTag::Timeout), "the error is not a Timeout: {}", e);
469 assert!(took >= Duration::from_millis(300) && took < Duration::from_secs(5),
470 "gave up after {:?}", took);
471 },
472 }
473 res!(store.folder_status(&u, &inbox));
474 let _ = fs::remove_dir_all(&root);
475 Ok(())
476}
477
478fn with_id(id: &str, tag: &str) -> Vec<u8> {
479 fmt!("From: bob@example.org\r\nTo: alice@test.local\r\nMessage-ID:\r\n {}\r\nSubject: {}\r\n\r\nid={}\r\n",
480 id, tag, tag).into_bytes()
481}
482
483/// A resend is filed once per Message-ID: a retry answers the UID already given, a message
484/// without one is filed each time, a copy dropped into new/ by another hand counts, an expunged
485/// copy no longer does, and IMAP APPEND is never deduplicated.
486#[test]
487fn a_redelivery_by_message_id_is_filed_once() -> Outcome<()> {
488 let root = res!(fresh_root("dedup"));
489 let store = res!(MaildirStore::new(root.clone(), "test.local"));
490 let u = user();
491 res!(store.ensure_user(&u));
492 let inbox = FolderName::new("INBOX");
493 let flags = MessageFlags { recent: true, ..MessageFlags::default() };
494
495 let first = res!(store.deliver(&u, &inbox, &with_id("<a@x>", "a1"), flags, None));
496 let resend = [b"Received: from mx2 by mx; Mon, 26 Oct 2026 10:00:00 +0000\r\n".as_slice(),
497 &with_id("<a@x>", "a1")].concat();
498 let again = res!(store.deliver(&u, &inbox, &resend, flags, None));
499 assert_eq!(first, again, "the retry answers the UID of the copy already filed");
500 assert_eq!(res!(uid_map(&store, &u, &inbox)).len(), 1);
501
502 res!(store.deliver(&u, &inbox, &body("plain"), flags, None));
503 res!(store.deliver(&u, &inbox, &body("plain"), flags, None));
504 assert_eq!(res!(uid_map(&store, &u, &inbox)).len(), 3, "no Message-ID, no deduplication");
505
506 // Another MDA's copy, never read by this store.
507 res!(fs::write(inbox_dir(&root).join("new").join("1.M1P1.other"), with_id("<b@x>", "b1")), IO, File);
508 res!(store.deliver(&u, &inbox, &with_id("<b@x>", "b1"), flags, None));
509 let map = res!(uid_map(&store, &u, &inbox));
510 assert_eq!(map.len(), 4, "the other hand's copy holds the Message-ID: {:?}", map);
511 assert_eq!(map.values().filter(|t| *t == "b1").count(), 1);
512
513 // Expunged, the copy is gone, and a later delivery is filed afresh.
514 res!(store.update_flags(&u, &inbox, first, FlagUpdate::Add(MessageFlags {
515 deleted: true, ..MessageFlags::default() })));
516 res!(store.expunge(&u, &inbox, None));
517 let after = res!(store.deliver(&u, &inbox, &with_id("<a@x>", "a3"), flags, None));
518 assert!(after.0 > first.0, "filed afresh under a new UID");
519
520 res!(store.append(&u, &inbox, &with_id("<a@x>", "a4"), MessageFlags::default(), None));
521 let map = res!(uid_map(&store, &u, &inbox));
522 assert!(map.values().any(|t| t == "a4"), "APPEND files what the client sends: {:?}", map);
523 let _ = fs::remove_dir_all(&root);
524 Ok(())
525}