use std::collections::{BTreeMap, BTreeSet};
use serde::{Deserialize, Serialize};
use crate::error::{SyncError, SyncResult};
use crate::record::RawRecord;
use crate::storage::LedgerStorage;
use crate::traits::Extras;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RemoteVersion {
pub record_name: String,
pub updated_at_ms: i64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Ledger {
pub scope: Option<String>,
pub change_token: Option<Vec<u8>>,
pub has_synced: bool,
pub tombstones: BTreeMap<String, i64>,
pub pending_tombstones: BTreeSet<String>,
pub remote_versions: BTreeMap<String, RemoteVersion>,
pub aliases: BTreeMap<String, BTreeSet<String>>,
pub pending_uploads: BTreeSet<String>,
pub pending_apply: BTreeMap<String, RawRecord>,
pub retry_after_ms: Option<i64>,
pub consecutive_failures: u32,
pub quarantined_total: u64,
pub flags: BTreeSet<String>,
pub extras: Extras,
}
impl Ledger {
pub fn bury(&mut self, id: &str, deleted_at_ms: i64) {
self.tombstones.insert(id.to_string(), deleted_at_ms);
self.pending_uploads.remove(id);
self.pending_apply.remove(id);
}
}
pub struct LedgerStore {
storage: Box<dyn LedgerStorage>,
ledger: Ledger,
pub recovered_from_corruption: bool,
}
impl LedgerStore {
pub fn open(storage: Box<dyn LedgerStorage>) -> SyncResult<Self> {
let bytes = storage.load().map_err(SyncError::Persistence)?;
let (ledger, corrupt) = match bytes {
None => (Ledger::default(), false),
Some(b) => match serde_json::from_slice::<Ledger>(&b) {
Ok(l) => (l, false),
Err(_) => (Ledger::default(), true),
},
};
Ok(Self {
storage,
ledger,
recovered_from_corruption: corrupt,
})
}
pub fn ledger(&self) -> &Ledger {
&self.ledger
}
pub fn mutate<R>(&mut self, change: impl FnOnce(&mut Ledger) -> R) -> SyncResult<R> {
let before = self.ledger.clone();
let out = change(&mut self.ledger);
let bytes =
serde_json::to_vec(&self.ledger).map_err(|e| SyncError::Persistence(e.to_string()))?;
if let Err(e) = self.storage.save(&bytes) {
self.ledger = before;
return Err(SyncError::Persistence(e));
}
Ok(out)
}
}