1use crate::files::Files;
8use crate::FileReadError;
9use coven_database::{
10 CopyReservation, DbError, DeviceOnlyCopy, FileHasher, FilePlace, FileRef, FolderCopy,
11 PreparedDeviceOnly,
12};
13use coven_foundation::{
14 files::{CopyFolder, CopyPathError, FileError, FileLease, FlushBatch, Flushed, RelativePath},
15 id_source::FileId,
16 progress::{Progress, ProgressReport},
17};
18use std::path::{Path, PathBuf};
19use std::sync::Arc;
20use tokio::sync::watch;
21
22#[derive(Clone, Copy, Debug, PartialEq, Eq)]
27pub enum DeviceOnlyStep {
28 Downloading {
30 file: FileId,
32 before: u64,
34 all: u64,
36 },
37}
38
39#[derive(Debug, thiserror::Error)]
43pub enum DeviceOnlyError {
44 #[error("file {file} is named twice")]
46 RepeatedFile {
47 file: FileId,
49 },
50 #[error(transparent)]
52 Path(CopyPathError),
53 #[error(transparent)]
62 Database(DbError),
63 #[error("downloading file {file} failed: {error}")]
65 Download {
66 file: FileId,
68 #[source]
70 error: FileReadError,
71 },
72 #[error(transparent)]
74 Disk(FileError),
75 #[error("cancelled")]
77 Cancelled,
78 #[error("{error}; removing the copies failed: {cleanup}")]
81 Cleanup {
82 error: Box<DeviceOnlyError>,
84 #[source]
86 cleanup: DbError,
87 },
88 #[error(transparent)]
90 Bug(#[from] coven_foundation::task::Bug),
91}
92
93impl From<CopyPathError> for DeviceOnlyError {
94 fn from(error: CopyPathError) -> Self {
95 match error {
96 CopyPathError::Bug(bug) => Self::Bug(bug),
97 error => Self::Path(error),
98 }
99 }
100}
101
102impl From<DbError> for DeviceOnlyError {
103 fn from(error: DbError) -> Self {
104 match error {
105 DbError::Bug(bug) => Self::Bug(bug),
106 error => Self::Database(error),
107 }
108 }
109}
110
111impl From<FileError> for DeviceOnlyError {
112 fn from(error: FileError) -> Self {
113 match error {
114 FileError::Bug(bug) => Self::Bug(bug),
115 error => Self::Disk(error),
116 }
117 }
118}
119
120impl coven_foundation::task::CarriesBug for DeviceOnlyError {
121 fn bug(&self) -> Option<&coven_foundation::task::Bug> {
122 match self {
123 Self::Bug(bug) => Some(bug),
124 Self::Path(error) => error.bug(),
125 Self::Database(error) => error.bug(),
126 Self::Download { error, .. } => error.bug(),
127 Self::Disk(error) => error.bug(),
128 Self::Cleanup { error, cleanup } => error.bug().or_else(|| cleanup.bug()),
129 Self::RepeatedFile { .. } | Self::Cancelled => None,
130 }
131 }
132}
133
134impl Files {
135 pub async fn prepare_device_only(
151 &self,
152 folder: &Path,
153 files: Vec<(FileId, RelativePath)>,
154 cancel: &watch::Receiver<bool>,
155 progress: watch::Sender<Option<Progress<DeviceOnlyStep>>>,
156 ) -> Result<PreparedDeviceOnly, DeviceOnlyError> {
157 self.inner.check_open()?;
158 let mut cancel = cancel.clone();
161 let lease = tokio::select! {
162 biased;
163 () = cancelled(&mut cancel) => return Err(DeviceOnlyError::Cancelled),
164 lease = self.inner.files.lease(1) => lease.expect("a budget has at least one place"),
165 };
166 let mut ids = Vec::new();
167 let mut paths = Vec::new();
168 for (file, path) in files {
169 if ids.contains(&file) {
170 return Err(DeviceOnlyError::RepeatedFile { file });
171 }
172 ids.push(file);
173 paths.push(path);
174 }
175 let refs = self.inner.database.device_only_files(ids).await?;
177 let folder = Arc::new(
178 CopyFolder::open(folder.to_owned(), self.inner.database.bugs().clone()).await?,
179 );
180 let plan = folder.plan(paths).await?;
181 let copies: Vec<FolderCopy> = plan
182 .files
183 .iter()
184 .map(|path| FolderCopy {
185 path: path.clone(),
186 temporary: path
187 .with_file_name(format!(".coven-{}.download", self.inner.ids.new_id())),
188 folders: plan
189 .folders
190 .iter()
191 .filter(|folder| path.starts_with(folder))
192 .cloned()
193 .collect(),
194 })
195 .collect();
196 let reservation = self.inner.database.record_copies(copies.clone()).await?;
199 let mut report = ProgressReport::new(progress, self.inner.clock.clone());
200 let downloaded = coven_foundation::task::caught(
203 "download files to make device-only",
204 download(
205 self,
206 &folder,
207 &reservation,
208 &plan.folders,
209 &refs,
210 &copies,
211 &lease,
212 &mut cancel,
213 &mut report,
214 ),
215 )
216 .await;
217 let error = match downloaded {
218 Ok(Ok((switches, flushed))) => {
219 return Ok(self.inner.database.prepared_device_only(
220 reservation,
221 switches,
222 flushed,
223 )?)
224 }
225 Ok(Err(error)) => error,
226 Err(bug) => DeviceOnlyError::Bug(bug),
227 };
228 let made = copies.into_iter().map(|copy| copy.path).collect();
229 let abandoned = self.inner.database.abandon_copies(made).await;
230 drop(reservation);
231 match abandoned {
232 Ok(()) => Err(error),
233 Err(cleanup) => Err(DeviceOnlyError::Cleanup { error: Box::new(error), cleanup }),
234 }
235 }
236}
237
238#[expect(clippy::too_many_arguments, reason = "the call's parts, each its own")]
252async fn download(
253 handle: &Files,
254 folder: &Arc<CopyFolder>,
255 reservation: &CopyReservation,
256 folders: &[PathBuf],
257 files: &[FileRef],
258 copies: &[FolderCopy],
259 lease: &FileLease,
260 cancel: &mut watch::Receiver<bool>,
261 report: &mut ProgressReport<DeviceOnlyStep>,
262) -> Result<(Vec<DeviceOnlyCopy>, Flushed), DeviceOnlyError> {
263 let bugs = handle.inner.database.bugs().clone();
264 for made in folders {
265 check(cancel)?;
266 let (owner, folder, made) = (handle.inner.clone(), folder.clone(), made.clone());
267 step(reservation, "make a folder for copies", &bugs, async move {
268 if folder.create_folder(made.clone()).await? {
270 owner.database.made_folder(&made).await?;
271 }
272 Ok(())
273 })
274 .await?;
275 }
276 let mut switches = Vec::new();
277 let mut batch = FlushBatch::new(handle.inner.database.bugs().clone());
278 let all = files.iter().map(FileRef::size).sum();
279 let mut before = 0;
280 for (file, copy) in files.iter().zip(copies) {
281 check(cancel)?;
282 report.begin(DeviceOnlyStep::Downloading { file: file.id(), before, all }, file.size());
283 let mut done = 0;
284 let download = |error| DeviceOnlyError::Download { file: file.id(), error };
285 let FilePlace::Cloud { location, .. } = file.place() else {
286 return Err(DbError::NotInCloud { file: file.id() }.into());
287 };
288 let location = location.clone();
289 let stream = handle.open_file_stream(file, lease).await.map_err(download)?;
290 let mut writer = {
291 let (folder, temporary) = (folder.clone(), copy.temporary.clone());
292 step(reservation, "create a copy", &bugs, async move {
293 Ok(folder.create_copy(temporary).await?)
294 })
295 .await?
296 };
297 let mut range = stream.read_range(0, file.size()).map_err(download)?;
301 let mut hashes = FileHasher::new();
302 loop {
303 let bytes = tokio::select! {
304 biased;
305 () = cancelled(cancel) => return Err(DeviceOnlyError::Cancelled),
306 bytes = range.next() => bytes.map_err(download)?,
307 };
308 let Some(bytes) = bytes else { break };
309 hashes.update(&bytes);
310 done += bytes.len() as u64;
311 writer = {
312 #[cfg(test)]
313 let owner = handle.inner.clone();
314 step(reservation, "append to a copy", &bugs, async move {
315 writer.append(&bytes).await?;
316 #[cfg(test)]
317 owner.pass_device_only_gate(DeviceOnlyPoint::Appended).await;
318 Ok(writer)
319 })
320 .await?
321 };
322 report.done(done);
323 }
324 before += file.size();
325 batch = {
326 let (owner, folder, path) = (handle.inner.clone(), folder.clone(), copy.path.clone());
327 step(reservation, "place a copy", &bugs, async move {
328 writer.publish(&path, &mut batch).await?;
329 #[cfg(test)]
330 owner.pass_device_only_gate(DeviceOnlyPoint::Renamed).await;
331 let observed = folder.observe(&path).await.map_err(DbError::from)?;
332 owner.database.place_copy(&observed).await?;
333 Ok(batch)
334 })
335 .await?
336 };
337 switches.push(DeviceOnlyCopy {
338 file: file.id(),
339 location,
340 path: copy.path.clone(),
341 hashes: hashes.finish(),
342 });
343 }
344 check(cancel)?;
345 Ok((switches, batch.flush().await?))
346}
347
348#[cfg(test)]
350#[derive(Clone, Copy, Debug, PartialEq, Eq)]
351pub(crate) enum DeviceOnlyPoint {
352 Appended,
354 Renamed,
356}
357
358#[cfg(test)]
361pub(crate) type DeviceOnlyGate =
362 (DeviceOnlyPoint, tokio::sync::oneshot::Sender<()>, tokio::sync::oneshot::Receiver<()>);
363
364impl crate::files::FilesInner {
365 #[cfg(test)]
367 async fn pass_device_only_gate(&self, point: DeviceOnlyPoint) {
368 let gate = {
369 let mut gate = coven_foundation::locks::lock_unpoisoned(&self.device_only_gate);
370 if gate.as_ref().is_some_and(|(at, _, _)| *at == point) {
371 gate.take()
372 } else {
373 None
374 }
375 };
376 if let Some((_, reached, resume)) = gate {
377 reached.send(()).ok();
378 resume.await.ok();
379 }
380 }
381}
382
383async fn step<T: Send + 'static>(
386 reservation: &CopyReservation,
387 operation: &'static str,
388 bugs: &coven_foundation::task::BugSinkRef,
389 work: impl std::future::Future<Output = Result<T, DeviceOnlyError>> + Send + 'static,
390) -> Result<T, DeviceOnlyError> {
391 reservation.run_step(operation, bugs.clone(), work).await.map_err(FileError::from)?
392}
393
394fn check(cancel: &watch::Receiver<bool>) -> Result<(), DeviceOnlyError> {
395 if *cancel.borrow() {
396 Err(DeviceOnlyError::Cancelled)
397 } else {
398 Ok(())
399 }
400}
401
402async fn cancelled(cancel: &mut watch::Receiver<bool>) {
404 loop {
405 if *cancel.borrow_and_update() {
406 return;
407 }
408 if cancel.changed().await.is_err() {
409 std::future::pending::<()>().await;
410 }
411 }
412}