1use std::collections::{BTreeMap, BTreeSet};
6
7use serde::{Deserialize, Serialize};
8
9use crate::error::{SyncError, SyncResult};
10use crate::record::RawRecord;
11use crate::storage::LedgerStorage;
12use crate::traits::Extras;
13
14#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
15pub struct RemoteVersion {
16 pub record_name: String,
17 pub updated_at_ms: i64,
18}
19
20#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
23pub struct ConsentRequest {
24 pub from: String,
25 pub to: String,
26}
27
28#[derive(Debug, Clone, Default, Serialize, Deserialize)]
29#[serde(default)]
30pub struct Ledger {
31 pub scope: Option<String>,
33 pub pending_consent: Option<ConsentRequest>,
36 pub withheld: BTreeSet<String>,
39 pub change_token: Option<Vec<u8>>,
40 pub has_synced: bool,
41 pub tombstones: BTreeMap<String, i64>,
43 pub pending_tombstones: BTreeSet<String>,
45 pub remote_versions: BTreeMap<String, RemoteVersion>,
47 pub aliases: BTreeMap<String, BTreeSet<String>>,
49 pub pending_uploads: BTreeSet<String>,
51 pub pending_apply: BTreeMap<String, RawRecord>,
53 pub retry_after_ms: Option<i64>,
55 pub consecutive_failures: u32,
56 pub quarantined_total: u64,
57 pub flags: BTreeSet<String>,
59 pub extras: Extras,
60}
61
62impl Ledger {
63 pub fn bury(&mut self, id: &str, deleted_at_ms: i64) {
65 self.tombstones.insert(id.to_string(), deleted_at_ms);
66 self.pending_uploads.remove(id);
67 self.pending_apply.remove(id);
68 }
69}
70
71pub struct LedgerStore {
72 storage: Box<dyn LedgerStorage>,
73 ledger: Ledger,
74 saved: Option<Vec<u8>>,
79 pub recovered_from_corruption: bool,
83}
84
85impl LedgerStore {
86 pub fn open(storage: Box<dyn LedgerStorage>) -> SyncResult<Self> {
87 let bytes = storage.load().map_err(SyncError::Persistence)?;
88 let (ledger, saved, corrupt) = match bytes {
89 None => (Ledger::default(), None, false),
90 Some(b) => match serde_json::from_slice::<Ledger>(&b) {
91 Ok(l) => (l, Some(b), false),
92 Err(_) => (Ledger::default(), None, true),
93 },
94 };
95 Ok(Self {
96 storage,
97 ledger,
98 saved,
99 recovered_from_corruption: corrupt,
100 })
101 }
102
103 pub fn ledger(&self) -> &Ledger {
104 &self.ledger
105 }
106
107 pub fn mutate<R>(&mut self, change: impl FnOnce(&mut Ledger) -> R) -> SyncResult<R> {
109 let out = change(&mut self.ledger);
110 let bytes = match serde_json::to_vec(&self.ledger) {
111 Ok(b) => b,
112 Err(e) => {
113 self.rollback();
114 return Err(SyncError::Persistence(e.to_string()));
115 }
116 };
117 if let Err(e) = self.storage.save(&bytes) {
118 self.rollback();
119 return Err(SyncError::Persistence(e));
120 }
121 self.saved = Some(bytes);
122 Ok(out)
123 }
124
125 fn rollback(&mut self) {
127 self.ledger = match &self.saved {
128 None => Ledger::default(),
129 Some(b) => serde_json::from_slice(b).unwrap_or_default(),
130 };
131 }
132}
133
134#[cfg(test)]
135mod tests {
136 use super::*;
137 use crate::storage::MemoryStorage;
138 use std::sync::atomic::{AtomicU32, Ordering};
139 use std::sync::Arc;
140
141 struct Flaky {
143 inner: MemoryStorage,
144 ok_saves: u32,
145 seen: Arc<AtomicU32>,
146 }
147
148 impl LedgerStorage for Flaky {
149 fn load(&self) -> Result<Option<Vec<u8>>, String> {
150 self.inner.load()
151 }
152 fn save(&self, bytes: &[u8]) -> Result<(), String> {
153 if self.seen.fetch_add(1, Ordering::SeqCst) >= self.ok_saves {
154 return Err("disk full".into());
155 }
156 self.inner.save(bytes)
157 }
158 }
159
160 fn flaky_over(mem: &MemoryStorage, ok_saves: u32) -> LedgerStore {
161 LedgerStore::open(Box::new(Flaky {
162 inner: mem.clone(),
163 ok_saves,
164 seen: Arc::new(AtomicU32::new(0)),
165 }))
166 .unwrap()
167 }
168
169 fn encoded(l: &Ledger) -> Vec<u8> {
170 serde_json::to_vec(l).unwrap()
171 }
172
173 #[test]
174 fn failed_save_restores_the_exact_prior_state_mid_apply() {
175 let mem = MemoryStorage::default();
176 let mut store = flaky_over(&mem, 2);
177 store
178 .mutate(|l| {
179 l.pending_uploads.insert("a".into());
180 l.bury("gone", 7);
181 l.change_token = Some(vec![1, 2, 3]);
182 })
183 .unwrap();
184 store
185 .mutate(|l| {
186 l.pending_uploads.insert("b".into());
187 l.flags.insert("x".into());
188 })
189 .unwrap();
190 let before = encoded(store.ledger());
191 let stored_before = mem.load().unwrap();
192
193 let err = store
195 .mutate(|l| {
196 l.pending_uploads.clear();
197 l.tombstones.clear();
198 l.change_token = None;
199 l.has_synced = true;
200 l.consecutive_failures = 9;
201 })
202 .unwrap_err();
203 assert!(matches!(err, SyncError::Persistence(_)));
204 assert_eq!(encoded(store.ledger()), before);
205 assert_eq!(mem.load().unwrap(), stored_before);
206
207 assert!(store.mutate(|l| l.retry_after_ms = Some(5)).is_err());
209 assert_eq!(encoded(store.ledger()), before);
210 }
211
212 #[test]
213 fn failed_first_save_restores_the_empty_ledger() {
214 let mem = MemoryStorage::default();
215 let mut store = flaky_over(&mem, 0);
216 assert!(store.mutate(|l| l.has_synced = true).is_err());
217 assert_eq!(encoded(store.ledger()), encoded(&Ledger::default()));
218 assert!(mem.load().unwrap().is_none());
219 }
220
221 #[test]
222 fn rollback_after_corrupt_open_restores_the_empty_ledger() {
223 let mem = MemoryStorage::default();
224 mem.save(b"not json").unwrap();
225 let mut store = flaky_over(&mem, 0);
226 assert!(store.recovered_from_corruption);
227 assert!(store.mutate(|l| l.has_synced = true).is_err());
228 assert!(!store.ledger().has_synced);
229 }
230
231 #[test]
232 fn rollback_after_open_of_a_stored_ledger_restores_it() {
233 let mem = MemoryStorage::default();
234 let mut seeded = Ledger::default();
235 seeded.pending_uploads.insert("keep".into());
236 mem.save(&encoded(&seeded)).unwrap();
237 let mut store = flaky_over(&mem, 0);
238 assert!(store.mutate(|l| l.pending_uploads.clear()).is_err());
239 assert!(store.ledger().pending_uploads.contains("keep"));
240 }
241}