Skip to main content

coven_database/
cache_progress.rs

1//! Pin progress as a query over committed cache coverage (§17.8, E8).
2//! Nothing here counts bytes in flight.
3
4use crate::sqlite::StoreSql;
5use crate::{DbError, FileRef, LiveQuery, StoreDatabase};
6use coven_foundation::id_source::{DeviceId, FileId};
7
8/// Verified cache coverage of requested files (§17.8, E8).
9#[derive(Clone, Debug, PartialEq, Eq)]
10pub struct PinProgress {
11    /// Files whose bytes have all been kept.
12    pub files_completed: u64,
13    /// Files requested, including those already present.
14    pub files_total: u64,
15    /// Verified plaintext bytes present in the committed cache for the
16    /// requested files.
17    pub bytes_cached: u64,
18    /// Total plaintext size of the requested files, including cached bytes.
19    pub bytes_total: u64,
20}
21
22/// Verified plaintext bytes of `file` the cache holds: a checked whole file,
23/// or each authenticated chunk without its tag. A file only on this device
24/// is wholly local; one only on another device has none here.
25#[expect(
26    clippy::map_err_ignore,
27    reason = "a stored value that won't convert or decode is DamagedDatabase"
28)]
29pub(crate) fn covered(db: &StoreSql, file: &FileRef, device: DeviceId) -> Result<u64, DbError> {
30    match file.place() {
31        crate::FilePlace::DeviceOnly { device: on } if on == device => return Ok(file.size()),
32        crate::FilePlace::DeviceOnly { .. } => return Ok(0),
33        crate::FilePlace::Cloud { .. } => {}
34    }
35    let object = crate::database::file_database::object_path_of(file)?;
36    if db.query_row(
37        "SELECT EXISTS(SELECT 1 FROM _coven_cache
38         WHERE namespace=?1 AND object_path=?2 AND chunk=?3)",
39        (file.namespace(), &object, crate::internal_schema::CACHE_COMPLETE_FILE),
40        |r| r.get::<_, bool>(0),
41    )? {
42        return Ok(file.size());
43    }
44    let cached = db.query_row(
45        "SELECT coalesce(sum(size-chunks*?3),0) FROM _coven_cache
46         WHERE namespace=?1 AND object_path=?2 AND chunk>=0",
47        (file.namespace(), &object, coven_crypto::FILE_CHUNK_TAG_LEN as i64),
48        |r| r.get::<_, i64>(0),
49    )?;
50    let cached = u64::try_from(cached).map_err(|_| DbError::DamagedDatabase)?;
51    if cached > file.size() {
52        return Err(DbError::DamagedDatabase);
53    }
54    Ok(cached)
55}
56
57/// Requested files' verified coverage. A pin completes with its checked
58/// whole file; a file only on this device is already whole here.
59pub(crate) fn pin_progress(
60    db: &StoreSql,
61    files: &[FileRef],
62    device: DeviceId,
63) -> Result<PinProgress, DbError> {
64    let mut progress = PinProgress {
65        files_completed: 0,
66        files_total: files.len() as u64,
67        bytes_cached: 0,
68        bytes_total: 0,
69    };
70    for file in files {
71        let cached = covered(db, file, device)?;
72        progress.bytes_cached =
73            crate::sqlite::add_total("requested file bytes cached", progress.bytes_cached, cached)?;
74        progress.bytes_total =
75            crate::sqlite::add_total("requested file bytes", progress.bytes_total, file.size())?;
76        let whole = match file.place() {
77            crate::FilePlace::DeviceOnly { device: on } => on == device,
78            crate::FilePlace::Cloud { .. } => crate::database::file_database::cache_kept(db, file)?,
79        };
80        if whole {
81            progress.files_completed += 1;
82        }
83    }
84    Ok(progress)
85}
86
87/// Pin answers in order; a file this device has no record of is `None`.
88/// The answer is whether `coven_pins` lists the file, so the app's SQL and
89/// this call agree. It reads no merge state, so a live query of it reruns
90/// only for those tables' changes.
91pub(crate) fn files_pinned(db: &StoreSql, files: &[FileId]) -> Result<Vec<Option<bool>>, DbError> {
92    files
93        .iter()
94        .map(|file| {
95            let (known, pinned): (bool, bool) = db.query_row(
96                "SELECT EXISTS(SELECT 1 FROM main.coven_files WHERE id=?1),
97                        EXISTS(SELECT 1 FROM coven_pins WHERE file=?1)",
98                [file],
99                |r| Ok((r.get(0)?, r.get(1)?)),
100            )?;
101            Ok(known.then_some(pinned))
102        })
103        .collect()
104}
105
106impl StoreDatabase {
107    /// Verified cache coverage for these fixed references, in one snapshot.
108    pub async fn pin_progress(&self, files: Vec<FileRef>) -> Result<PinProgress, DbError> {
109        let device = self.local_device()?;
110        self.read_committed(move |db| pin_progress(db, &files, device)).await
111    }
112    /// The same pre-built cache query with the same fixed references.
113    pub fn subscribe_pin_progress<E>(&self, files: Vec<FileRef>) -> LiveQuery<PinProgress, E>
114    where
115        E: From<DbError> + coven_foundation::task::CarriesBug + Send + 'static,
116    {
117        let device = self.local_device().ok();
118        self.follow(move |db| {
119            pin_progress(db, &files, device.ok_or(DbError::StoreClosed)?).map_err(E::from)
120        })
121    }
122    /// Whether each file is pinned, one answer per file in order.
123    pub async fn files_pinned(&self, files: Vec<FileId>) -> Result<Vec<Option<bool>>, DbError> {
124        self.read_committed(move |db| files_pinned(db, &files)).await
125    }
126    /// The same internal query, live.
127    pub fn subscribe_files_pinned<E>(&self, files: Vec<FileId>) -> LiveQuery<Vec<Option<bool>>, E>
128    where
129        E: From<DbError> + coven_foundation::task::CarriesBug + Send + 'static,
130    {
131        self.follow(move |db| files_pinned(db, &files).map_err(E::from))
132    }
133}
134
135#[cfg(test)]
136#[path = "cache_progress_tests.rs"]
137mod tests;