coven_database/
cache_progress.rs1use crate::sqlite::StoreSql;
5use crate::{DbError, FileRef, LiveQuery, StoreDatabase};
6use coven_foundation::id_source::{DeviceId, FileId};
7
8#[derive(Clone, Debug, PartialEq, Eq)]
10pub struct PinProgress {
11 pub files_completed: u64,
13 pub files_total: u64,
15 pub bytes_cached: u64,
18 pub bytes_total: u64,
20}
21
22#[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
57pub(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
87pub(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 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 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 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 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;