1. 1//! The trash (docs/plans/data-architecture-plan.md, M0): a session moved to
2. 2//! the trash is hidden everywhere, from the session lists, every search a
3. 3//! person or the model can run, its transcript and export, and digests,
4. 4//! and can be restored. Erasure, which removes it for good, is later work
5. 5//! (M7). This module is the one place any of those readers asks.
6. 6//!
7. 7//! The set is keyed by session id in the shared data home, like the archive,
8. 8//! so a single mutation and its bulk form share one boundary check
9. 9//! (AGENTS.md invariant 22) in the server.
10. 10
11. 11use std::collections::{HashMap, HashSet};
12. 12use std::path::{Path, PathBuf};
13. 13use std::sync::{Mutex, OnceLock};
14. 14
15. 15fn path(shared_home: &Path) -> PathBuf {
16. 16 shared_home.join("deleted.json")
17. 17}
18. 18
19. 19fn read(shared_home: &Path) -> HashMap<String, bool> {
20. 20 std::fs::read_to_string(path(shared_home))
21. 21 .ok()
22. 22 .and_then(|text| serde_json::from_str(&text).ok())
23. 23 .unwrap_or_default()
24. 24}
25. 25
26. 26/// Every session id in the trash.
27. 27pub fn trashed(shared_home: &Path) -> HashSet<String> {
28. 28 read(shared_home)
29. 29 .into_iter()
30. 30 .filter_map(|(id, trashed)| trashed.then_some(id))
31. 31 .collect()
32. 32}
33. 33
34. 34pub fn is_trashed(shared_home: &Path, session_id: &str) -> bool {
35. 35 read(shared_home).get(session_id).copied().unwrap_or(false)
36. 36}
37. 37
38. 38/// What a cross-session search must skip: the trash and, when there is one,
39. 39/// the session doing the searching.
40. 40pub fn search_exclusions(shared_home: &Path, current: Option<&str>) -> HashSet<String> {
41. 41 let mut excluded = trashed(shared_home);
42. 42 excluded.extend(current.map(str::to_string));
43. 43 excluded
44. 44}
45. 45
46. 46/// Moves sessions into or out of the trash, atomically and one writer at a
47. 47/// time within the process.
48. 48pub fn set(shared_home: &Path, session_ids: &[String], trashed: bool) -> std::io::Result<()> {
49. 49 static WRITE: OnceLock<Mutex<()>> = OnceLock::new();
50. 50 let _guard = WRITE
51. 51 .get_or_init(|| Mutex::new(()))
52. 52 .lock()
53. 53 .unwrap_or_else(std::sync::PoisonError::into_inner);
54. 54 let mut map = read(shared_home);
55. 55 for id in session_ids {
56. 56 if trashed {
57. 57 map.insert(id.clone(), true);
58. 58 } else {
59. 59 map.remove(id);
60. 60 }
61. 61 }
62. 62 std::fs::create_dir_all(shared_home)?;
63. 63 let temp = path(shared_home).with_extension("json.tmp");
64. 64 std::fs::write(
65. 65 &temp,
66. 66 serde_json::to_string(&map).map_err(std::io::Error::other)?,
67. 67 )?;
68. 68 std::fs::rename(temp, path(shared_home))
69. 69}
70. 70
71. 71#[cfg(test)]
72. 72#[allow(clippy::unwrap_used)]
73. 73mod tests {
74. 74 use super::*;
75. 75
76. 76 #[test]
77. 77 fn a_session_moves_into_and_out_of_the_trash() {
78. 78 let home = tempfile::tempdir().unwrap();
79. 79 assert!(!is_trashed(home.path(), "s1"));
80. 80 set(home.path(), &["s1".into(), "s2".into()], true).unwrap();
81. 81 assert!(is_trashed(home.path(), "s1"));
82. 82 assert_eq!(trashed(home.path()).len(), 2);
83. 83 set(home.path(), &["s1".into()], false).unwrap();
84. 84 assert!(!is_trashed(home.path(), "s1"));
85. 85 let excluded = search_exclusions(home.path(), Some("current"));
86. 86 assert!(excluded.contains("s2") && excluded.contains("current"));
87. 87 assert!(!excluded.contains("s1"));
88. 88 }
89. 89}
90. 90