1use crate::sqlite::StoreSql;
7use crate::store_call::StoreCall;
8use crate::write_encoding::{audience, counter};
9use crate::{write_schema::WriteSchema, DbError};
10use coven_format::{admin::SnapshotId, snapshot::SnapshotHeader};
11use coven_foundation::id_source::DeviceId;
12use coven_merge::{Audience, WriteId};
13use sqlive::rusqlite::params;
14
15#[derive(Clone, Debug, PartialEq, Eq)]
17pub struct RaiseCapture {
18 pub audience: Audience,
20 pub version: u32,
22 pub through: WriteId,
24 pub covers: u64,
26}
27
28pub(crate) fn capture(
29 db: &StoreSql,
30 _schema: &WriteSchema,
31 marker: WriteId,
32 version: u32,
33) -> Result<bool, DbError> {
34 let state = crate::store_state_tables::read(db)?;
35 db.execute("DELETE FROM _coven_raise_captures", [])?;
36 let Some(member) = state
37 .store
38 .as_ref()
39 .and_then(|_| state.devices.get(&marker.device))
40 .map(|device| device.member)
41 else {
42 return Ok(false);
43 };
44 let rebuilding = crate::reload_gate::rebuilding(db)?;
47 for selected in state.readable_audiences(&member) {
48 if rebuilding.contains_key(&selected) {
49 continue;
50 }
51 db.execute("INSERT INTO _coven_raise_captures(audience,version,through,covers) VALUES(?1,?2,?3,?4)",params![&selected,version,marker.number.to_be_bytes(),crate::sequence::applied(db)?.to_be_bytes()])?;
52 }
53 Ok(true)
54}
55
56pub(crate) fn capture_created(
62 db: &StoreSql,
63 call: &StoreCall<'_>,
64 schema: &WriteSchema,
65) -> Result<(), DbError> {
66 if breaking_version(db)? == 0 || !provisional(db)?.is_empty() {
67 return Ok(());
68 }
69 let device = call
70 .local_device()
71 .ok_or(DbError::Invariant { what: "a writer connection observes this device" })?;
72 let queued = db.query(
73 "SELECT number FROM _coven_uploads WHERE device=?1 ORDER BY number DESC",
74 [device],
75 |r| counter(r.get::<_, Vec<u8>>(0)?),
76 )?;
77 for number in queued {
78 let marker = WriteId { device, number };
79 let header = crate::upload::queued(db, marker)?
80 .ok_or(DbError::Invariant { what: "a queued write has its header" })?
81 .header;
82 if header.disposition == coven_format::write::WriteDisposition::Migration {
83 capture(db, schema, marker, crate::transaction_constants::schema_version(db, call)?)?;
84 return Ok(());
85 }
86 }
87 Ok(())
88}
89
90pub(crate) fn capture_made(
99 db: &StoreSql,
100 call: &StoreCall<'_>,
101 circle: coven_foundation::id_source::CircleId,
102 state: &crate::StoreState,
103 operation: Option<&crate::migration::MigrationOperation>,
104) -> Result<(), DbError> {
105 let audience = Audience::Circle(circle);
106 let device = call
107 .local_device()
108 .ok_or(DbError::Invariant { what: "a writer connection observes this device" })?;
109 let made = state
110 .devices
111 .get(&device)
112 .is_some_and(|local| local.active() && state.reads_circle(circle, &local.member));
113 if !made || state.reached(&audience) >= breaking_version(db)? {
114 return Ok(());
115 }
116 let through = match captured_through(db)? {
119 Some(through) => through,
120 None => crate::write_metadata::newest_number(db, device)?.unwrap_or(0),
121 };
122 capture_circle(db, call, &audience, through, operation)
123}
124
125fn capture_circle(
129 db: &StoreSql,
130 call: &StoreCall<'_>,
131 audience: &Audience,
132 through: u64,
133 operation: Option<&crate::migration::MigrationOperation>,
134) -> Result<(), DbError> {
135 db.execute(
136 "INSERT INTO _coven_raise_captures(audience,version,through,covers) VALUES(?1,?2,?3,?4)",
137 params![
138 audience,
139 crate::transaction_constants::schema_version(db, call)?,
140 through.to_be_bytes(),
141 crate::sequence::applied(db)?.to_be_bytes()
142 ],
143 )?;
144 if let Some(operation) = operation {
147 if crate::operation::of_kind(db, crate::operation_kind::SCHEMA_RAISE)?.is_empty() {
148 journal(db, operation, crate::transaction_constants::schema_version(db, call)?)?;
149 }
150 }
151 Ok(())
152}
153
154pub(crate) fn capture_rebuilt(
159 db: &StoreSql,
160 call: &StoreCall<'_>,
161 audience: &Audience,
162 marker: WriteId,
163 operation: Option<&crate::migration::MigrationOperation>,
164) -> Result<(), DbError> {
165 capture_circle(db, call, audience, marker.number, operation)
166}
167
168pub(crate) fn journal(
171 db: &StoreSql,
172 operation: &crate::migration::MigrationOperation,
173 version: u32,
174) -> Result<(), DbError> {
175 let new = operation(version)?;
176 let id = crate::operation::insert(db, &new)?;
177 crate::operation::advance(
178 db,
179 &crate::OperationUpdate { id, previous: 0, last_step: 1, data: new.data },
180 )
181}
182
183pub(crate) fn raise_to(
184 db: &StoreSql,
185 _tables: &[crate::SyncedTable],
186 device: DeviceId,
187 version: u32,
188) -> Result<bool, DbError> {
189 if captures(db, device)?.is_empty() {
190 return Ok(false);
191 }
192 let newest = crate::write_metadata::newest_number(db, device)?
194 .ok_or(DbError::Invariant { what: "a raise capture's device has a write" })?;
195 db.execute(
196 "UPDATE _coven_raise_captures SET version=?1,through=?2,covers=?3",
197 params![version, newest.to_be_bytes(), crate::sequence::applied(db)?.to_be_bytes()],
198 )?;
199 Ok(true)
200}
201
202pub(crate) fn follow(db: &StoreSql, marker: WriteId) -> Result<(), DbError> {
205 for capture in captures(db, marker.device)? {
206 db.execute(
207 "UPDATE _coven_raise_captures SET through=?1 WHERE audience=?2 AND version=?3",
208 params![marker.number.to_be_bytes(), capture.audience, capture.version],
209 )?;
210 }
211 Ok(())
212}
213
214pub(crate) fn prepare(
215 db: &StoreSql,
216 _schema: &WriteSchema,
217 device: DeviceId,
218 selected: &Audience,
219 version: u32,
220) -> Result<Option<RaiseCapture>, DbError> {
221 db.execute(
222 "UPDATE _coven_raise_captures SET covers=?1 WHERE audience=?2 AND version=?3",
223 params![crate::sequence::applied(db)?.to_be_bytes(), selected, version],
224 )?;
225 Ok(captures(db, device)?
226 .into_iter()
227 .find(|capture| capture.audience == *selected && capture.version == version))
228}
229
230pub(crate) fn captured_through(db: &StoreSql) -> Result<Option<u64>, DbError> {
231 Ok(db.query_row("SELECT max(through) FROM _coven_raise_captures", [], |r| {
232 r.get::<_, Option<Vec<u8>>>(0)?.map(counter).transpose()
233 })?)
234}
235
236pub(crate) fn provisional(db: &StoreSql) -> Result<Vec<(Audience, u32, u64)>, DbError> {
237 Ok(db.query(
238 "SELECT audience,version,covers FROM _coven_raise_captures ORDER BY audience",
239 [],
240 |r| Ok((audience(r, 0)?, r.get(1)?, counter(r.get(2)?)?)),
241 )?)
242}
243
244pub(crate) fn captures(db: &StoreSql, device: DeviceId) -> Result<Vec<RaiseCapture>, DbError> {
245 Ok(db.query(
246 "SELECT audience,version,through,covers FROM _coven_raise_captures ORDER BY audience",
247 [],
248 |r| {
249 Ok(RaiseCapture {
250 audience: audience(r, 0)?,
251 version: r.get(1)?,
252 through: WriteId { device, number: counter(r.get(2)?)? },
253 covers: counter(r.get(3)?)?,
254 })
255 },
256 )?)
257}
258
259pub(crate) fn write<E>(
260 db: &StoreSql,
261 call: &StoreCall<'_>,
262 schema: &WriteSchema,
263 id: SnapshotId,
264 version: u32,
265 begin: impl FnOnce(&SnapshotHeader) -> Result<(), E>,
266 emit: impl FnMut(Vec<u8>) -> Result<(), E>,
267) -> Result<u32, crate::SnapshotWriteError<E>> {
268 let capture = captures(db, id.device)?
269 .into_iter()
270 .find(|capture| capture.audience == id.audience && capture.version == version)
271 .ok_or(DbError::DamagedDatabase)?;
272 if crate::upload::unconfirmed(db, capture.through)?.is_some() {
273 return Err(DbError::ClaimUnsettled.into());
274 }
275 if capture.covers != crate::sequence::applied(db)? {
276 return Err(DbError::CaptureChanged.into());
277 }
278 crate::snapshot_write::write(db, call, schema, id, begin, emit)
279}
280
281pub(crate) fn breaking_version(db: &StoreSql) -> Result<u32, DbError> {
285 Ok(db.query_row("SELECT minimum FROM _coven_snapshot_schema WHERE singleton=1", [], |r| {
286 r.get(0)
287 })?)
288}
289
290pub(crate) fn require(db: &StoreSql, minimum: u32) -> Result<(), DbError> {
293 db.execute("UPDATE _coven_snapshot_schema SET minimum=?1 WHERE singleton=1", [minimum])?;
294 Ok(())
295}
296
297pub(crate) fn loaded(db: &StoreSql, audience: &Audience, version: u32) -> Result<(), DbError> {
300 db.execute(
301 "DELETE FROM _coven_raise_captures WHERE audience=?1 AND version<=?2",
302 params![audience, version],
303 )?;
304 Ok(())
305}
306
307pub(crate) fn supersede(db: &StoreSql, audience: &Audience) -> Result<(), DbError> {
309 db.execute("DELETE FROM _coven_raise_captures WHERE audience=?1", [audience])?;
310 Ok(())
311}
312
313pub(crate) fn discard(db: &StoreSql, audience: &Audience, version: u32) -> Result<(), DbError> {
314 db.execute(
315 "DELETE FROM _coven_raise_captures WHERE audience=?1 AND version=?2",
316 params![audience, version],
317 )?;
318 Ok(())
319}
320
321#[cfg(test)]
322#[path = "raise_capture_tests.rs"]
323pub(crate) mod tests;