1use crate::sqlite::StoreSql;
28use crate::DbError;
29use std::time::SystemTime;
30
31pub(crate) const SYNC_STATUS: &str = "coven_sync_status";
33
34const SAVE_LOCATION: &str = "UPDATE coven_sync_status SET storage=?1,provider=?2,location=?5,
36 moved=CASE WHEN ?4 THEN NULL ELSE moved END,
37 halted=CASE WHEN ?4 THEN 0 ELSE halted END,
38 last_synced=CASE WHEN ?3 IS NULL THEN last_synced
39 ELSE max(coalesce(last_synced,?3),?3) END
40 WHERE singleton=1 AND (storage IS NOT ?1 OR provider IS NOT ?2 OR location IS NOT ?5
41 OR (?4 AND (moved IS NOT NULL OR halted=1))
42 OR (?3 IS NOT NULL AND (last_synced IS NULL OR last_synced<?3)))";
43
44const SAVE_LAST_PASS: &str = "UPDATE coven_sync_status SET last_pass=?1,moved=NULL
47 WHERE singleton=1 AND halted=0 AND (last_pass IS NOT ?1 OR moved IS NOT NULL)";
48
49pub(super) const TABLE: &str = "CREATE TABLE coven_sync_status (
51 singleton INTEGER PRIMARY KEY NOT NULL CHECK(singleton=1),
52 storage TEXT NOT NULL CHECK(storage IN ('none','signed_out','connected')),
53 provider TEXT,
54 location TEXT,
55 last_pass BLOB,
56 moved TEXT CHECK(moved IN ('read','claimed')),
57 last_synced INTEGER CHECK(last_synced>=0),
58 starts INTEGER NOT NULL CHECK(starts>=0),
59 halted INTEGER NOT NULL CHECK(halted IN (0,1)),
60 CHECK((storage='none')=(provider IS NULL)),
61 CHECK((storage='none')=(location IS NULL))
62 ) STRICT;
63 INSERT INTO coven_sync_status(singleton,storage,provider,location,last_pass,moved,last_synced,starts,halted)
64 VALUES(1,'none',NULL,NULL,NULL,NULL,NULL,0,0);";
65
66#[derive(Clone, Copy, Debug, PartialEq, Eq)]
70pub enum RecordedLocation<P> {
71 None,
73 SignedOut(P),
75 Connected(P),
77}
78
79impl<P> RecordedLocation<P> {
80 pub fn is_connected(&self) -> bool {
82 matches!(self, Self::Connected(_))
83 }
84
85 pub fn map<Q>(self, name: impl FnOnce(P) -> Q) -> RecordedLocation<Q> {
87 match self {
88 Self::None => RecordedLocation::None,
89 Self::SignedOut(provider) => RecordedLocation::SignedOut(name(provider)),
90 Self::Connected(provider) => RecordedLocation::Connected(name(provider)),
91 }
92 }
93
94 pub fn try_map<Q, E>(
97 self,
98 name: impl FnOnce(P) -> Result<Q, E>,
99 ) -> Result<RecordedLocation<Q>, E> {
100 Ok(match self {
101 Self::None => RecordedLocation::None,
102 Self::SignedOut(provider) => RecordedLocation::SignedOut(name(provider)?),
103 Self::Connected(provider) => RecordedLocation::Connected(name(provider)?),
104 })
105 }
106}
107
108#[derive(Clone, Copy, Debug, PartialEq, Eq)]
111pub enum PassMove {
112 Read,
114 Claimed,
116}
117
118impl PassMove {
119 fn column(self) -> &'static str {
120 match self {
121 Self::Read => "read",
122 Self::Claimed => "claimed",
123 }
124 }
125
126 fn from_column(column: &str) -> Result<Self, DbError> {
127 match column {
128 "read" => Ok(Self::Read),
129 "claimed" => Ok(Self::Claimed),
130 _ => Err(DbError::DamagedDatabase),
131 }
132 }
133}
134
135#[derive(Clone, Debug, PartialEq, Eq)]
139pub struct StoredLocation {
140 pub provider: String,
142 pub location: String,
144}
145
146#[derive(Clone, Debug, PartialEq, Eq)]
148pub struct SyncStatusRow {
149 pub location: RecordedLocation<String>,
151 pub last_pass: Option<Vec<u8>>,
154 pub moved: Option<PassMove>,
156 pub last_synced: Option<SystemTime>,
159}
160
161fn millis(time: SystemTime) -> Result<i64, DbError> {
164 crate::stored_millis::since_epoch(time, crate::stored_millis::Round::Down).ok_or(
165 DbError::Invariant {
166 what: "a sync finishes between the Unix epoch and SQLite's last millisecond",
167 },
168 )
169}
170
171fn columns(location: &RecordedLocation<StoredLocation>) -> (&'static str, Option<&StoredLocation>) {
173 match location {
174 RecordedLocation::None => ("none", None),
175 RecordedLocation::SignedOut(stored) => ("signed_out", Some(stored)),
176 RecordedLocation::Connected(stored) => ("connected", Some(stored)),
177 }
178}
179
180#[cfg(test)]
182pub(crate) fn read(db: &StoreSql) -> Result<SyncStatusRow, DbError> {
183 db.query_row(
184 "SELECT storage,provider,last_pass,moved,last_synced FROM coven_sync_status
185 WHERE singleton=1",
186 [],
187 |row| Ok(decode(row, 0)),
188 )?
189}
190
191pub(crate) fn decode(
195 values: &impl crate::sync_facts::FactValues,
196 first: usize,
197) -> Result<SyncStatusRow, DbError> {
198 let storage: String = values.get(first)?;
199 let provider: Option<String> = values.get(first + 1)?;
200 let moved: Option<String> = values.get(first + 3)?;
201 let last_synced: Option<i64> = values.get(first + 4)?;
202 let location = match (storage.as_str(), provider) {
203 ("none", None) => RecordedLocation::None,
204 ("signed_out", Some(provider)) => RecordedLocation::SignedOut(provider),
205 ("connected", Some(provider)) => RecordedLocation::Connected(provider),
206 _ => return Err(DbError::DamagedDatabase),
207 };
208 Ok(SyncStatusRow {
209 location,
210 last_pass: values.get(first + 2)?,
211 moved: moved.as_deref().map(PassMove::from_column).transpose()?,
212 last_synced: last_synced.map(crate::stored_millis::stored_time).transpose()?,
213 })
214}
215
216macro_rules! save_location_row {
220 ($db:expr, $location:expr, $finished:expr, $opening:expr) => {{
221 let (storage, stored) = columns($location);
222 let provider = stored.map(|stored| stored.provider.as_str());
223 let recorded = stored.map(|stored| stored.location.as_str());
224 let finished: Option<i64> = $finished;
225 $db.execute(
226 SAVE_LOCATION,
227 sqlive::rusqlite::params![storage, provider, finished, $opening, recorded],
228 )?;
229 Ok::<(), DbError>(())
230 }};
231}
232
233pub(crate) fn save_location(
238 db: &StoreSql,
239 location: &RecordedLocation<StoredLocation>,
240 finished: Option<SystemTime>,
241 opening: bool,
242) -> Result<(), DbError> {
243 let finished = finished.map(millis).transpose()?;
244 save_location_row!(db, location, finished, opening)
245}
246
247pub(crate) fn save_moved(db: &StoreSql, moved: PassMove) -> Result<(), DbError> {
249 db.execute(
250 "UPDATE coven_sync_status SET moved=?1 WHERE singleton=1 AND halted=0 AND moved IS NOT ?1",
251 [moved.column()],
252 )?;
253 Ok(())
254}
255
256pub(crate) fn save_start(db: &StoreSql) -> Result<(), DbError> {
258 db.execute("UPDATE coven_sync_status SET starts=starts+1 WHERE singleton=1", [])?;
259 Ok(())
260}
261
262pub(crate) fn save_last_pass(db: &StoreSql, last_pass: &[u8]) -> Result<(), DbError> {
267 db.execute(SAVE_LAST_PASS, [last_pass])?;
268 Ok(())
269}
270
271#[cfg(any(test, feature = "test-utils"))]
274pub fn save_location_outside_store(
275 connection: &sqlive::rusqlite::Connection,
276 location: &RecordedLocation<StoredLocation>,
277) -> Result<(), DbError> {
278 save_location_row!(connection, location, None, false)
279}
280
281#[cfg(any(test, feature = "test-utils"))]
284pub fn save_last_pass_outside_store(
285 connection: &sqlive::rusqlite::Connection,
286 last_pass: &[u8],
287) -> Result<(), DbError> {
288 connection.execute(SAVE_LAST_PASS, [last_pass])?;
289 Ok(())
290}
291
292pub(crate) fn save_halt(db: &StoreSql, last_pass: &[u8]) -> Result<(), DbError> {
296 db.execute(
297 "UPDATE coven_sync_status SET last_pass=?1,moved=NULL,halted=1 WHERE singleton=1",
298 [last_pass],
299 )?;
300 Ok(())
301}
302
303pub(crate) fn save_pass_end(
307 db: &StoreSql,
308 last_pass: &[u8],
309 finished: Option<SystemTime>,
310) -> Result<(), DbError> {
311 let finished = finished.map(millis).transpose()?;
312 db.execute(
313 "UPDATE coven_sync_status SET last_pass=?1,moved=NULL,
314 last_synced=CASE WHEN ?2 IS NULL THEN last_synced
315 ELSE max(coalesce(last_synced,?2),?2) END
316 WHERE singleton=1 AND halted=0 AND (last_pass IS NOT ?1 OR moved IS NOT NULL
317 OR (?2 IS NOT NULL AND (last_synced IS NULL OR last_synced<?2)))",
318 sqlive::rusqlite::params![last_pass, finished],
319 )?;
320 Ok(())
321}
322
323#[cfg(test)]
324#[path = "internal_schema_sync_status_tests.rs"]
325mod tests;