1use std::collections::BTreeMap;
6use std::sync::{Arc, Mutex};
7
8use crate::error::{SyncError, SyncResult};
9use crate::record::RawRecord;
10use crate::traits::{Backend, ChangePage, RecordOutcome, SavePolicy};
11
12#[derive(Default)]
13struct Zone {
14 records: BTreeMap<String, (u64, RawRecord)>,
15 seq: u64,
16 deletions: Vec<(u64, String)>,
17 page_size: usize,
19 offline: bool,
20 expire_token_once: bool,
21 fail_after_saves: Option<usize>,
23 save_calls: usize,
24 saved_records: usize,
25 concurrent_write: Option<RawRecord>,
28}
29
30#[derive(Clone, Default)]
31pub struct MemoryBackend {
32 zone: Arc<Mutex<Zone>>,
33}
34
35impl MemoryBackend {
36 pub fn new() -> Self {
37 Self::default()
38 }
39 pub fn set_offline(&self, offline: bool) {
40 self.zone.lock().unwrap().offline = offline;
41 }
42 pub fn set_page_size(&self, n: usize) {
43 self.zone.lock().unwrap().page_size = n;
44 }
45 pub fn expire_token_once(&self) {
46 self.zone.lock().unwrap().expire_token_once = true;
47 }
48 pub fn fail_after_saves(&self, n: Option<usize>) {
51 self.zone.lock().unwrap().fail_after_saves = n;
52 }
53 pub fn concurrent_write_before_next_save(&self, record: RawRecord) {
55 self.zone.lock().unwrap().concurrent_write = Some(record);
56 }
57 pub fn save_calls(&self) -> usize {
58 self.zone.lock().unwrap().save_calls
59 }
60 pub fn saved_records(&self) -> usize {
61 self.zone.lock().unwrap().saved_records
62 }
63 pub fn put_record(&self, mut record: RawRecord) {
64 let mut z = self.zone.lock().unwrap();
65 z.seq += 1;
66 let seq = z.seq;
67 record.modified_ms = Some(seq as i64);
68 record.change_tag = Some(seq.to_string());
69 z.records.insert(record.record_name.clone(), (seq, record));
70 }
71 pub fn delete_record(&self, name: &str) {
72 let mut z = self.zone.lock().unwrap();
73 z.seq += 1;
74 let seq = z.seq;
75 z.records.remove(name);
76 z.deletions.push((seq, name.to_string()));
77 }
78 pub fn record(&self, name: &str) -> Option<RawRecord> {
79 self.zone
80 .lock()
81 .unwrap()
82 .records
83 .get(name)
84 .map(|(_, r)| r.clone())
85 }
86 pub fn record_count(&self) -> usize {
87 self.zone.lock().unwrap().records.len()
88 }
89
90 fn check(&self) -> SyncResult<()> {
91 if self.zone.lock().unwrap().offline {
92 Err(SyncError::RetryAfter {
93 secs: 15.0,
94 detail: "no network".into(),
95 })
96 } else {
97 Ok(())
98 }
99 }
100}
101
102impl Backend for MemoryBackend {
103 fn prepare(&self) -> SyncResult<()> {
104 self.check()
105 }
106
107 fn fetch_changes(&self, since: Option<&[u8]>) -> SyncResult<ChangePage> {
108 self.check()?;
109 let mut z = self.zone.lock().unwrap();
110 if z.expire_token_once && since.is_some() {
111 z.expire_token_once = false;
112 return Err(SyncError::TokenExpired);
113 }
114 let token = since
115 .and_then(|b| <[u8; 8]>::try_from(b).ok())
116 .map(u64::from_le_bytes)
117 .unwrap_or(0);
118 let mut changed: Vec<(u64, RawRecord)> = z
119 .records
120 .values()
121 .filter(|(s, _)| *s > token)
122 .cloned()
123 .collect();
124 changed.sort_by_key(|(s, _)| *s);
125 let limit = if z.page_size == 0 {
126 usize::MAX
127 } else {
128 z.page_size
129 };
130 let more = changed.len() > limit;
131 changed.truncate(limit);
132 let new_token = if more {
133 changed.last().map(|(s, _)| *s).unwrap_or(token)
134 } else {
135 z.seq
136 };
137 let deleted: Vec<String> = z
138 .deletions
139 .iter()
140 .filter(|(s, _)| *s > token && *s <= new_token)
141 .map(|(_, n)| n.clone())
142 .collect();
143 Ok(ChangePage {
144 records: changed.into_iter().map(|(_, r)| r).collect(),
145 deleted_record_names: deleted,
146 new_token: Some(new_token.to_le_bytes().to_vec()),
147 more_coming: more,
148 })
149 }
150
151 fn fetch_record(&self, name: &str) -> SyncResult<Option<RawRecord>> {
152 self.check()?;
153 Ok(self.record(name))
154 }
155
156 fn save_records(
157 &self,
158 records: &[RawRecord],
159 policy: SavePolicy,
160 ) -> SyncResult<Vec<RecordOutcome>> {
161 self.check()?;
162 let injected = self.zone.lock().unwrap().concurrent_write.take();
163 if let Some(r) = injected {
164 self.put_record(r);
165 }
166 let mut out = Vec::with_capacity(records.len());
167 let mut budget = {
168 let mut z = self.zone.lock().unwrap();
169 z.save_calls += 1;
170 z.fail_after_saves
171 };
172 for r in records {
173 match budget {
174 Some(0) => out.push(RecordOutcome {
175 record_name: r.record_name.clone(),
176 result: Err(SyncError::Transient("injected save failure".into())),
177 server_record: None,
178 }),
179 _ => {
180 if policy == SavePolicy::IfServerUnchanged {
181 let server = self.record(&r.record_name);
182 let stale = match (&server, &r.change_tag) {
183 (Some(s), tag) => s.change_tag != *tag,
184 (None, Some(_)) => {
185 out.push(RecordOutcome {
186 record_name: r.record_name.clone(),
187 result: Err(SyncError::Transient("unknown item".into())),
188 server_record: None,
189 });
190 continue;
191 }
192 (None, None) => false,
193 };
194 if stale {
195 out.push(RecordOutcome {
196 record_name: r.record_name.clone(),
197 result: Err(SyncError::Conflict),
198 server_record: server,
199 });
200 continue;
201 }
202 }
203 if let Some(b) = budget.as_mut() {
204 *b -= 1;
205 }
206 self.put_record(r.clone());
207 self.zone.lock().unwrap().saved_records += 1;
208 out.push(RecordOutcome {
209 record_name: r.record_name.clone(),
210 result: Ok(()),
211 server_record: None,
212 });
213 }
214 }
215 }
216 if let Some(b) = budget {
217 self.zone.lock().unwrap().fail_after_saves = Some(b);
218 }
219 Ok(out)
220 }
221}