coven_sync/
file_status.rs1use super::FilesMode;
7use crate::FileSourceFailure;
8use crate::{
9 files::{file_failure::upload_subject, Files, FilesInner},
10 FileMissingReason, FileReadError, PendingReason, PendingRecord,
11};
12use coven_database::{DbError, FileLocation, FilePlace, FileRef};
13use coven_format::file::FileHeader;
14use coven_foundation::id_source::DeviceId;
15use coven_storage::StoredObject;
16
17#[derive(Clone, Debug, PartialEq, Eq)]
19pub enum FileStatus {
20 Available,
22 Uploading,
24 DeviceOnly {
28 device: DeviceId,
30 },
31 Missing {
33 device: DeviceId,
35 reason: FileMissingReason,
37 },
38}
39
40pub(crate) struct Uploading {
43 pub(crate) upload: i64,
44 pub(crate) location: FileLocation,
45 pub(crate) of: coven_database::MoveId,
46 pub(crate) failure: Option<FileSourceFailure>,
47}
48
49pub(crate) type Local = Option<Option<FileSourceFailure>>;
53
54pub(crate) fn status<E>(
58 uploader: DeviceId,
59 remote: impl FnOnce() -> Result<bool, E>,
60 here: Local,
61) -> Result<FileStatus, E> {
62 match here {
63 Some(None) => Ok(FileStatus::Uploading),
64 Some(Some(failure)) => {
65 Ok(FileStatus::Missing { device: uploader, reason: FileMissingReason::Source(failure) })
66 }
67 None => Ok(if remote()? {
68 FileStatus::Available
69 } else {
70 FileStatus::Missing { device: uploader, reason: FileMissingReason::Lost }
71 }),
72 }
73}
74
75impl Files {
76 pub async fn file_status(&self, file: &FileRef) -> Result<FileStatus, FileReadError> {
82 self.inner.check_open()?;
83 let file = self.inner.current(file).await?;
84 let location = match file.place() {
85 FilePlace::DeviceOnly { device } => {
86 return match self.inner.local(&file).await? {
87 Some(here) => status::<FileReadError>(
88 here.location.uploader(),
89 || Ok(false),
90 Some(here.failure),
91 ),
92 None => match self.inner.unreadable(&file, device).await {
93 FileReadError::DeviceOnly { .. } => Ok(FileStatus::DeviceOnly { device }),
94 error => Err(error),
95 },
96 };
97 }
98 FilePlace::Cloud { location, .. } => location,
99 };
100 let storage = super::file_storage::connected(self.inner.settled().await?)?;
101 let path = location.path(self.inner.directory.id());
102 let remote = match storage.status(&path).await? {
103 Some(object) => complete(&file, &object).map(|()| true),
104 None => Ok(false),
105 };
106 status(location.uploader(), || remote, None)
107 }
108}
109
110impl<M: FilesMode> FilesInner<M> {
111 pub(crate) async fn current(&self, file: &FileRef) -> Result<FileRef, FileReadError> {
115 match self.database.file_ref(file.id()).await {
116 Ok(current) => Ok(current),
117 Err(DbError::FileAbsent { .. }) => Ok(file.clone()),
118 Err(error) => Err(error.into()),
119 }
120 }
121
122 pub(crate) async fn unreadable(&self, file: &FileRef, device: DeviceId) -> FileReadError {
125 match self.database.file_ref(file.id()).await {
126 Err(error @ DbError::FileAbsent { .. }) => error.into(),
127 _ => FileReadError::DeviceOnly { file: file.id(), device },
128 }
129 }
130
131 pub(crate) async fn local(&self, file: &FileRef) -> Result<Option<Uploading>, FileReadError> {
136 let Some(records) = self.database.records() else {
137 return Ok(None);
138 };
139 let evidence = records
140 .local_evidence::<PendingRecord>(file, upload_subject, |id| {
141 crate::PendingSubject::Move { id }
142 })
143 .await?;
144 Ok(evidence.map(|evidence| {
145 let original = evidence.moving.and_then(|record| match record.reason {
146 PendingReason::Original { path, failure }
147 if evidence.original.as_ref() == Some(&path) =>
148 {
149 Some(failure)
150 }
151 _ => None,
152 });
153 let copy = evidence.record.and_then(|record| match record.reason {
154 PendingReason::FileUnavailable(FileMissingReason::Source(failure)) => Some(failure),
155 _ => None,
156 });
157 Uploading {
158 upload: evidence.upload,
159 location: evidence.location,
160 of: evidence.of,
161 failure: original.or(copy),
162 }
163 }))
164 }
165
166 pub(crate) fn absence_error(&self, file: &FileRef, location: &FileLocation) -> FileReadError {
169 FileReadError::Missing { id: file.id().to_string(), device: location.uploader() }
170 }
171}
172
173#[expect(
177 clippy::map_err_ignore,
178 reason = "a size whose encrypted layout overflows fails the integrity check"
179)]
180pub(crate) fn complete(file: &FileRef, object: &StoredObject) -> Result<(), FileReadError> {
181 let expected = FileHeader::new(file.size())
182 .encrypted_size()
183 .map_err(|_| FileReadError::Integrity { id: file.id().to_string(), cause: None })?;
184 if object.size == expected {
185 Ok(())
186 } else {
187 Err(FileReadError::Integrity { id: file.id().to_string(), cause: None })
188 }
189}