field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

adapter.rs (2669B)

      1 use super::*;
      2 use radroots_storage::outbox::BoxFuture;
      3 use tera_core::runtime::backup::{
      4     ApplicationBackupManifest, BackupHost, BackupMediaLease, BackupMediaRequirement,
      5 };
      6 
      7 pub(crate) struct BackupHostAdapter(pub(crate) Box<dyn TeraBackupHost>);
      8 
      9 impl BackupHost for BackupHostAdapter {
     10     fn load_candidate(
     11         &self,
     12         request: BackupRequest,
     13     ) -> BoxFuture<'_, Result<Option<Vec<u8>>, BackupError>> {
     14         Box::pin(async move {
     15             self.0
     16                 .load_candidate((&request).into())
     17                 .await
     18                 .map_err(host_error)
     19         })
     20     }
     21     fn retain_media(
     22         &self,
     23         request: BackupRequest,
     24         media: Vec<BackupMediaRequirement>,
     25     ) -> BoxFuture<'_, Result<Vec<BackupMediaLease>, BackupError>> {
     26         Box::pin(async move {
     27             let media = media
     28                 .into_iter()
     29                 .map(|media| FfiBackupMedia {
     30                     lease_identifier: request.lease_identifier(&media.sha256),
     31                     sha256: media.sha256,
     32                     byte_length: media.byte_length,
     33                 })
     34                 .collect();
     35             Ok(self
     36                 .0
     37                 .retain_media((&request).into(), media)
     38                 .await
     39                 .map_err(host_error)?
     40                 .into_iter()
     41                 .map(Into::into)
     42                 .collect())
     43         })
     44     }
     45     fn persist_candidate(
     46         &self,
     47         manifest: ApplicationBackupManifest,
     48     ) -> BoxFuture<'_, Result<(), BackupError>> {
     49         Box::pin(async move {
     50             self.0
     51                 .persist_candidate(manifest.try_into()?)
     52                 .await
     53                 .map_err(host_error)
     54         })
     55     }
     56     fn publish_complete(
     57         &self,
     58         manifest: ApplicationBackupManifest,
     59     ) -> BoxFuture<'_, Result<(), BackupError>> {
     60         Box::pin(async move {
     61             self.0
     62                 .publish_complete(manifest.try_into()?)
     63                 .await
     64                 .map_err(host_error)
     65         })
     66     }
     67 }
     68 
     69 impl TryFrom<ApplicationBackupManifest> for FfiBackupManifest {
     70     type Error = BackupError;
     71     fn try_from(value: ApplicationBackupManifest) -> Result<Self, Self::Error> {
     72         Ok(Self {
     73             request: value.request().into(),
     74             media: value
     75                 .media()
     76                 .iter()
     77                 .map(|media| FfiBackupMedia {
     78                     sha256: media.sha256.clone(),
     79                     byte_length: media.byte_length,
     80                     lease_identifier: media.identifier.clone(),
     81                 })
     82                 .collect(),
     83             manifest: value.encode()?,
     84         })
     85     }
     86 }