Skip to main content

rightkit_sync/
memory.rs

1//! In-process zone with real change-feed semantics. Reference behaviour for
2//! real backends and the fixture for the convergence tests. Clones share one
3//! zone, so two engines on two clones play two devices.
4
5use 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 for delta fetches (0 = unlimited) to exercise `more_coming`.
18    page_size: usize,
19    offline: bool,
20    expire_token_once: bool,
21    /// Succeed for this many record saves, then fail the rest of the call.
22    fail_after_saves: Option<usize>,
23    save_calls: usize,
24    saved_records: usize,
25    /// Another device's write that lands just before the next save call is
26    /// evaluated (the window between the engine's fetch and its save).
27    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    /// Next `save_records` calls accept `n` records in total, then fail the
49    /// rest with a transient error (partial batch success).
50    pub fn fail_after_saves(&self, n: Option<usize>) {
51        self.zone.lock().unwrap().fail_after_saves = n;
52    }
53    /// Simulate a concurrent write by another device between fetch and save.
54    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}