1use crate::*;
4use coven_foundation::id_source::DeviceId;
5use std::sync::Arc;
6
7pub struct StorageConnection<P: ?Sized = dyn ProviderOps> {
10 provider: Arc<P>,
11 device: DeviceId,
14 publications: Arc<dyn PublicationGate>,
15 cooldown: Arc<dyn Cooldown>,
16 transfers: Arc<TransferBudget>,
17 clock: coven_foundation::clock::ClockRef,
20 requests: crate::request_tally::RequestTally,
22 setup: Option<SetupWaits>,
26}
27
28impl<P: ProviderOps + ?Sized> StorageConnection<P> {
29 #[cfg(test)]
31 pub(crate) fn from_provider(provider: Arc<P>) -> Self {
32 Self::with_gate(
33 provider,
34 crate::test_utils::DEVICE,
35 Arc::new(crate::test_utils::UnrestrictedPublications),
36 Arc::new(NoCooldown),
37 Arc::new(TransferBudget::new(TransferLimits::default())),
38 Arc::new(coven_foundation::clock::FixedClock::new(std::time::UNIX_EPOCH)),
39 )
40 }
41
42 pub(crate) fn with_gate(
43 provider: Arc<P>,
44 device: DeviceId,
45 publications: Arc<dyn PublicationGate>,
46 cooldown: Arc<dyn Cooldown>,
47 transfers: Arc<TransferBudget>,
48 clock: coven_foundation::clock::ClockRef,
49 ) -> Self {
50 Self {
51 provider,
52 device,
53 publications,
54 cooldown,
55 transfers,
56 requests: crate::request_tally::RequestTally::new(clock.clone()),
57 clock,
58 setup: None,
59 }
60 }
61
62 pub fn during_setup(&self, waits: SetupWaits) -> Self {
71 Self {
72 provider: self.provider.clone(),
73 device: self.device,
74 publications: self.publications.clone(),
75 cooldown: self.cooldown.clone(),
76 transfers: self.transfers.clone(),
77 requests: crate::request_tally::RequestTally::new(self.clock.clone()),
78 clock: self.clock.clone(),
79 setup: Some(waits),
80 }
81 }
82
83 pub fn requests(&self) -> crate::RequestCounts {
85 self.requests.counts()
86 }
87
88 pub(crate) async fn resend_after(&self, error: &StorageError) -> bool {
91 match &self.setup {
92 Some(waits) => waits.wait_to_resend(self.clock.as_ref(), error).await,
93 None => false,
94 }
95 }
96
97 pub(crate) async fn resent<T, F: std::future::Future<Output = Result<T, StorageError>>>(
101 &self,
102 mut request: impl FnMut() -> F,
103 ) -> Result<T, StorageError> {
104 match &self.setup {
105 Some(waits) => waits.resend(self.clock.as_ref(), request).await,
106 None => request().await,
107 }
108 }
109
110 pub(crate) fn received(&self, bytes: u64) {
112 self.requests.received(bytes);
113 }
114
115 pub(crate) async fn send<T>(
117 &self,
118 kind: crate::RequestKind,
119 bytes: u64,
120 request: impl std::future::Future<Output = T>,
121 ) -> T {
122 self.requests.send(kind, bytes, request).await
123 }
124
125 pub(crate) fn cooling(&self) -> Result<(), StorageError> {
128 crate::cooldown::cooling(self.cooldown.as_ref())
129 }
130
131 fn publication(&self, path: &ObjectPath) -> Result<PublicationRequest, StorageError> {
132 let request = PublicationRequest::new(self.publications.clone(), path.clone());
133 request.check()?;
134 Ok(request)
135 }
136
137 fn unfinished_publication(
141 &self,
142 session: &UploadSession,
143 ) -> Result<Option<PublicationRequest>, StorageError> {
144 session.check(&self.config())?;
145 if session.is_complete() {
146 return Ok(None);
147 }
148 self.publication(session.path()).map(Some)
149 }
150
151 async fn account_change<T>(
155 &self,
156 change: impl std::future::Future<Output = Result<T, StorageError>>,
157 ) -> Result<T, StorageError> {
158 if self.config().provider() == CloudProvider::S3 {
159 return change.await;
160 }
161 self.cooling()?;
162 let result = self.send(RequestKind::Account, 0, change).await;
163 self.observed(result).await
164 }
165
166 pub(crate) async fn observed<T>(
169 &self,
170 result: Result<T, StorageError>,
171 ) -> Result<T, StorageError> {
172 crate::cooldown::observed(self.cooldown.as_ref(), result).await
173 }
174 async fn end_left(&self, left: &[LeftUpload]) -> Result<(), StorageError> {
176 for upload in left {
177 self.cooling()?;
178 self.observed(
179 self.send(upload.request(), 0, self.provider.end_left_upload(upload)).await,
180 )
181 .await?;
182 }
183 Ok(())
184 }
185 pub async fn end_detection_run(
189 &self,
190 store: coven_foundation::id_source::StoreId,
191 run: uuid::Uuid,
192 ) -> Result<(), StorageError> {
193 self.cooling()?;
194 let left = self
195 .observed(
196 self.send(RequestKind::List, 0, self.provider.detection_leftovers(store, run))
197 .await,
198 )
199 .await?;
200 self.end_left(&left).await
201 }
202 async fn list_checked(&self, prefix: &ObjectPrefix) -> Result<Vec<StoredObject>, StorageError> {
203 let mut listing = ObjectListing::new(prefix.clone(), self.config().provider());
204 self.send(RequestKind::List, 0, self.provider.list(&mut listing)).await?;
205 Ok(listing.finish())
206 }
207
208 pub(crate) async fn replace_object(
213 &self,
214 previous: &StoredObject,
215 bytes: &[u8],
216 ) -> Result<(), StorageError> {
217 let mut resent = false;
218 loop {
219 let replaced = self.replace_once(previous, bytes).await;
220 if let Err(error) = &replaced {
221 if resent && error.own_failure() == Some(StorageFailure::Conflict) {
222 let stored = self.read(&previous.path).await?;
223 return if stored == bytes { Ok(()) } else { replaced };
224 }
225 if self.resend_after(error).await {
226 resent = true;
227 continue;
228 }
229 }
230 return replaced;
231 }
232 }
233
234 async fn create_once(
235 &self,
236 path: &ObjectPath,
237 bytes: &[u8],
238 sent: &ByteProgress,
239 ) -> Result<Option<StoredObject>, StorageError> {
240 self.cooling()?;
241 let publication = self.publication(path)?;
242 let created = crate::transfer::upload_bytes(self, path, bytes, sent, async {
243 let object = self
244 .send(
245 RequestKind::Create,
246 bytes.len() as u64,
247 self.provider.create(&publication, path, bytes, sent, self.device),
248 )
249 .await?;
250 if let Some(object) = &object {
251 object.check(path)?;
252 }
253 Ok(object)
254 })
255 .await;
256 self.observed(created).await
257 }
258
259 async fn stream_once(
260 &self,
261 path: &ObjectPath,
262 range: Option<ByteRange>,
263 received: &ByteProgress,
264 ) -> Result<ObjectStream<'_>, StorageError> {
265 self.cooling()?;
266 let download = match path.object_id() {
270 Some(_) => Some(self.transfers.download().await),
271 None => None,
272 };
273 self.cooling()?;
274 let stream = self
277 .observed(
278 self.send(RequestKind::Read, 0, self.provider.stream_object(path, range, received))
279 .await,
280 )
281 .await?;
282 stream.check(path, range)?;
283 let start = range.map_or(0, ByteRange::start);
284 let stream = match download {
285 Some(lease) => stream.with_download(lease),
286 None => stream,
287 };
288 Ok(stream.heard_by(received.starting_at(start)).counted(&self.requests))
289 }
290
291 async fn replace_once(
292 &self,
293 previous: &StoredObject,
294 bytes: &[u8],
295 ) -> Result<(), StorageError> {
296 self.cooling()?;
297 previous.check(&previous.path)?;
298 crate::transfer::check_single_request(bytes.len() as u64, self.single_request_limit())?;
299 let publication = self.publication(&previous.path)?;
300 let result = self
301 .send(
302 RequestKind::Replace,
303 bytes.len() as u64,
304 self.provider.replace(&publication, previous, bytes, self.device),
305 )
306 .await;
307 self.observed(result.map_err(StorageError::replacement)).await
308 }
309
310 pub(crate) async fn begin_upload_checked(
311 &self,
312 path: &ObjectPath,
313 total: u64,
314 ) -> Result<UploadSession, StorageError> {
315 if path.is_replaceable() || total == 0 {
318 return Err(StorageFailure::InvalidPart.into());
319 }
320 let publication = self.publication(path)?;
321 self.send(
322 RequestKind::Upload,
323 0,
324 self.provider.begin_upload(&publication, path, total, self.device),
325 )
326 .await
327 }
328 pub(crate) fn part_permit<'a>(
332 &self,
333 session: &mut UploadSession,
334 bytes: &'a [u8],
335 ) -> Result<PartPermit<'a>, StorageError> {
336 let config = self.config();
337 let part = match config.provider() {
339 CloudProvider::S3 | CloudProvider::CloudKit => {
340 let part = session.next_part(bytes.len())?;
341 session.check(&config)?;
342 part
343 }
344 CloudProvider::Dropbox | CloudProvider::OneDrive => {
345 session.check(&config)?;
346 session.next_part(bytes.len())?
347 }
348 };
349 let publication = self.publication(session.path())?;
350 Ok(PartPermit::admit(session, bytes, part, publication))
351 }
352 pub(crate) async fn send_permitted(
353 &self,
354 permit: PartPermit<'_>,
355 session: &mut UploadSession,
356 sent: &ByteProgress,
357 ) -> Result<(), StorageError> {
358 let PartPermit { bytes, part, publication, .. } = permit;
359 let sent = sent.starting_at(part.start);
361 let result = self
362 .send(
363 RequestKind::Upload,
364 bytes.len() as u64,
365 self.provider.upload_part(&publication, session, bytes, part.end, &sent),
366 )
367 .await;
368 result
369 }
370 pub(crate) async fn finish_upload_checked(
371 &self,
372 session: &mut UploadSession,
373 ) -> Result<(), StorageError> {
374 let Some(publication) = self.unfinished_publication(session)? else {
375 return Ok(());
376 };
377 let result = self
378 .send(RequestKind::Upload, 0, self.provider.finish_upload(&publication, session))
379 .await;
380 result
381 }
382 pub(crate) async fn abort_upload_checked(
383 &self,
384 session: &UploadSession,
385 ) -> Result<(), StorageError> {
386 let Some(publication) = self.unfinished_publication(session)? else {
387 return Ok(());
388 };
389 self.send(RequestKind::Upload, 0, self.provider.abort_upload(&publication, session)).await
390 }
391}
392
393#[async_trait::async_trait]
394impl<P: ProviderOps + ?Sized> Storage for StorageConnection<P> {
395 fn config(&self) -> StorageConfig {
396 self.provider.config()
397 }
398 fn single_request_limit(&self) -> u64 {
399 self.provider.single_request_limit()
400 }
401 fn read_part_size(&self) -> Option<std::num::NonZeroU64> {
402 self.provider.read_part_size()
403 }
404 async fn s3_access_key_id(&self) -> Option<String> {
405 self.provider.s3_access_key_id().await
406 }
407 async fn set_s3_credentials(&self, credentials: S3Credentials) -> Result<(), StorageError> {
408 self.provider.set_s3_credentials(credentials).await
409 }
410 async fn set_oauth_tokens(&self, tokens: OAuthTokens) -> Result<(), StorageError> {
411 ConnectionCredentials {
412 location: self.config(),
413 credentials: StorageCredentials::OAuth(tokens.clone()),
414 }
415 .validate()?;
416 self.provider.set_oauth_tokens(tokens).await
417 }
418 async fn account(&self) -> Result<String, StorageError> {
419 self.resent(move || async move {
420 self.cooling()?;
421 self.observed(self.send(RequestKind::Account, 0, self.provider.account()).await).await
422 })
423 .await
424 }
425 async fn account_identity(&self) -> Result<crate::ProviderAccount, StorageError> {
426 self.resent(move || async move {
427 self.cooling()?;
428 self.observed(
429 self.send(RequestKind::Account, 0, self.provider.account_identity()).await,
430 )
431 .await
432 })
433 .await
434 }
435 async fn create_reporting(
440 &self,
441 path: &ObjectPath,
442 bytes: &[u8],
443 sent: &ByteProgress,
444 ) -> Result<Option<StoredObject>, StorageError> {
445 let mut resent = false;
446 loop {
447 let created = self.create_once(path, bytes, sent).await;
448 if let Err(error) = &created {
449 if resent && error.own_failure() == Some(StorageFailure::AlreadyExists) {
450 let stored = self.read_object(path, None).await?;
451 return if stored.bytes == bytes { Ok(Some(stored.metadata)) } else { created };
452 }
453 if self.resend_after(error).await {
454 resent = true;
455 continue;
456 }
457 }
458 return created;
459 }
460 }
461 async fn replace(&self, previous: &StoredObject, bytes: &[u8]) -> Result<(), StorageError> {
462 if !previous.path.is_replaceable() {
463 return Err(StorageFailure::InvalidPath.into());
464 }
465 self.replace_object(previous, bytes).await
466 }
467 async fn status(&self, path: &ObjectPath) -> Result<Option<StoredObject>, StorageError> {
468 self.resent(move || async move {
469 self.cooling()?;
470 self.observed(
471 async {
472 let object =
473 self.send(RequestKind::Status, 0, self.provider.status(path)).await?;
474 if let Some(object) = &object {
475 object.check(path)?;
476 }
477 Ok(object)
478 }
479 .await,
480 )
481 .await
482 })
483 .await
484 }
485 async fn stream_object_reporting(
486 &self,
487 path: &ObjectPath,
488 range: Option<ByteRange>,
489 received: &ByteProgress,
490 ) -> Result<ObjectStream<'_>, StorageError> {
491 loop {
492 match self.stream_once(path, range, received).await {
493 Err(error) if !self.resend_after(&error).await => return Err(error),
494 Err(_) => {}
495 stream => return stream,
496 }
497 }
498 }
499 async fn list(&self, prefix: &ObjectPrefix) -> Result<Vec<StoredObject>, StorageError> {
500 self.resent(move || async move {
501 self.cooling()?;
502 self.observed(self.list_checked(prefix).await).await
503 })
504 .await
505 }
506
507 async fn delete(&self, path: &ObjectPath) -> Result<(), StorageError> {
508 self.resent(move || async move {
509 self.cooling()?;
510 self.observed(self.send(RequestKind::Delete, 0, self.provider.delete(path)).await).await
511 })
512 .await
513 }
514 async fn end_settled_claims(
515 &self,
516 store: coven_foundation::id_source::StoreId,
517 through: u64,
518 ) -> Result<(), StorageError> {
519 self.cooling()?;
520 let left = self
521 .observed(
522 self.send(
523 RequestKind::List,
524 0,
525 self.provider.settled_claim_uploads(store, through),
526 )
527 .await,
528 )
529 .await?;
530 self.end_left(&left).await
531 }
532 async fn end_device_uploads(
533 &self,
534 store: coven_foundation::id_source::StoreId,
535 device: DeviceId,
536 ) -> Result<(), StorageError> {
537 self.cooling()?;
538 let left = self
539 .observed(
540 self.send(RequestKind::List, 0, self.provider.device_uploads(store, device)).await,
541 )
542 .await?;
543 self.end_left(&left).await
544 }
545 async fn grant_access(&self, account: &str) -> Result<AccessGrant, StorageError> {
546 self.account_change(self.provider.grant_access(account)).await
547 }
548 async fn revoke_access(&self, account: &str) -> Result<Vec<RetainedAccess>, StorageError> {
549 self.account_change(self.provider.revoke_access(account)).await
550 }
551 async fn join(
552 &self,
553 store: coven_foundation::id_source::StoreId,
554 invitation: &StorageInvitation,
555 ) -> Result<(), StorageError> {
556 self.cooling()?;
557 let result = async {
558 invitation.check(&self.config())?;
559 self.send(RequestKind::Account, 0, self.provider.join(invitation)).await?;
560 self.check_location_claim(store).await?;
561 self.status(&ObjectPath::floor(store)).await?;
562 Ok(())
563 }
564 .await;
565 self.observed(result).await
566 }
567 async fn leave(&self, invitation: &StorageInvitation) -> Result<(), StorageError> {
568 self.cooling()?;
569 let result = async {
570 invitation.check(&self.config())?;
571 self.send(RequestKind::Account, 0, self.provider.leave(invitation)).await
572 }
573 .await;
574 self.observed(result).await
575 }
576 async fn begin_upload(
577 &self,
578 path: &ObjectPath,
579 total: u64,
580 ) -> Result<UploadSession, StorageError> {
581 self.cooling()?;
582 self.observed(self.begin_upload_checked(path, total).await).await
583 }
584 async fn restart_upload(&self, expired: &UploadSession) -> Result<UploadSession, StorageError> {
585 self.cooling()?;
586 let result = async {
587 expired.check(&self.config())?;
588 if expired.is_complete() {
589 return Err(StorageFailure::InvalidPart.into());
590 }
591 if matches!(expired.state, crate::session::SessionState::S3Restart { .. }) {
592 self.abort_upload_checked(expired).await?;
593 }
594 self.begin_upload_checked(expired.path(), expired.total_bytes()).await
595 }
596 .await;
597 self.observed(result).await
598 }
599 async fn resume_upload(&self, session: &mut UploadSession) -> Result<(), StorageError> {
600 self.cooling()?;
601 let result = async {
602 let Some(publication) = self.unfinished_publication(session)? else {
603 return Ok(());
604 };
605 let result = self
606 .send(RequestKind::Upload, 0, self.provider.resume_upload(&publication, session))
607 .await;
608 result
609 }
610 .await;
611 self.observed(result).await
612 }
613 fn admit_part<'a>(
614 &self,
615 session: &mut UploadSession,
616 bytes: &'a [u8],
617 ) -> Result<PartPermit<'a>, StorageError> {
618 self.cooling()?;
619 self.part_permit(session, bytes)
620 }
621 async fn send_part(
622 &self,
623 permit: PartPermit<'_>,
624 session: &mut UploadSession,
625 sent: &ByteProgress,
626 ) -> Result<(), StorageError> {
627 self.observed(self.send_permitted(permit, session, sent).await).await
628 }
629 async fn send_independent_part(
630 &self,
631 session: &UploadSession,
632 offset: u64,
633 bytes: &[u8],
634 sent: &ByteProgress,
635 ) -> Result<ConfirmedPart, StorageError> {
636 self.cooling()?;
637 if !session.parts_independent() {
638 return Err(StorageFailure::InvalidPart.into());
639 }
640 session.part_end(offset, bytes.len())?;
643 session.check(&self.config())?;
644 let publication = self.publication(session.path())?;
645 let sent = sent.starting_at(offset);
647 let result = self
648 .send(
649 RequestKind::Upload,
650 bytes.len() as u64,
651 self.provider.send_independent_part(&publication, session, offset, bytes, &sent),
652 )
653 .await;
654 self.observed(result).await
655 }
656 async fn finish_upload(&self, session: &mut UploadSession) -> Result<(), StorageError> {
657 self.cooling()?;
658 self.observed(self.finish_upload_checked(session).await).await
659 }
660 async fn abort_upload(&self, session: &UploadSession) -> Result<(), StorageError> {
661 self.cooling()?;
662 self.observed(self.abort_upload_checked(session).await).await
663 }
664}
665
666#[cfg(test)]
669impl<P: ?Sized> StorageConnection<P> {
670 pub(crate) fn provider(&self) -> &Arc<P> {
671 &self.provider
672 }
673
674 pub(crate) fn provider_mut(&mut self) -> &mut Arc<P> {
675 &mut self.provider
676 }
677
678 pub(crate) fn set_device(&mut self, device: DeviceId) {
679 self.device = device;
680 }
681
682 pub(crate) fn set_publications(&mut self, publications: Arc<dyn PublicationGate>) {
683 self.publications = publications;
684 }
685}
686
687#[path = "folder_label.rs"]
691mod folder_label;
692#[path = "location_claim.rs"]
693pub(crate) mod location_claim;
694#[cfg(any(test, feature = "test-utils"))]
695#[path = "test_utils.rs"]
696pub mod test_utils;
697
698#[cfg(test)]
699#[path = "connection_tests.rs"]
700mod tests;