src/backup/read_chunk.rs

   1 use std::future::Future;
   2 use std::pin::Pin;
   3 use std::sync::Arc;
   4
   5 use anyhow::{bail, Error};
   6
   7 use pbs_datastore::crypt_config::{CryptConfig, CryptMode};
   8 use pbs_datastore::data_blob::DataBlob;
   9 use pbs_datastore::read_chunk::{ReadChunk, AsyncReadChunk};
  10
  11 use super::datastore::DataStore;
  12
  13 #[derive(Clone)]
  14 pub struct LocalChunkReader {
  15     store: Arc<DataStore>,
  16     crypt_config: Option<Arc<CryptConfig>>,
  17     crypt_mode: CryptMode,
  18 }
  19
  20 impl LocalChunkReader {
  21     pub fn new(store: Arc<DataStore>, crypt_config: Option<Arc<CryptConfig>>, crypt_mode: CryptMode) -> Self {
  22         Self {
  23             store,
  24             crypt_config,
  25             crypt_mode,
  26         }
  27     }
  28
  29     fn ensure_crypt_mode(&self, chunk_mode: CryptMode) -> Result<(), Error> {
  30         match self.crypt_mode {
  31             CryptMode::Encrypt => {
  32                 match chunk_mode {
  33                     CryptMode::Encrypt => Ok(()),
  34                     CryptMode::SignOnly | CryptMode::None => bail!("Index and chunk CryptMode don't match."),
  35                 }
  36             },
  37             CryptMode::SignOnly | CryptMode::None => {
  38                 match chunk_mode {
  39                     CryptMode::Encrypt => bail!("Index and chunk CryptMode don't match."),
  40                     CryptMode::SignOnly | CryptMode::None => Ok(()),
  41                 }
  42             },
  43         }
  44     }
  45 }
  46
  47 impl ReadChunk for LocalChunkReader {
  48     fn read_raw_chunk(&self, digest: &[u8; 32]) -> Result<DataBlob, Error> {
  49         let chunk = self.store.load_chunk(digest)?;
  50         self.ensure_crypt_mode(chunk.crypt_mode()?)?;
  51         Ok(chunk)
  52     }
  53
  54     fn read_chunk(&self, digest: &[u8; 32]) -> Result<Vec<u8>, Error> {
  55         let chunk = ReadChunk::read_raw_chunk(self, digest)?;
  56
  57         let raw_data = chunk.decode(self.crypt_config.as_ref().map(Arc::as_ref), Some(digest))?;
  58
  59         Ok(raw_data)
  60     }
  61 }
  62
  63 impl AsyncReadChunk for LocalChunkReader {
  64     fn read_raw_chunk<'a>(
  65         &'a self,
  66         digest: &'a [u8; 32],
  67     ) -> Pin<Box<dyn Future<Output = Result<DataBlob, Error>> + Send + 'a>> {
  68         Box::pin(async move{
  69             let (path, _) = self.store.chunk_path(digest);
  70
  71             let raw_data = tokio::fs::read(&path).await?;
  72
  73             let chunk = DataBlob::load_from_reader(&mut &raw_data[..])?;
  74             self.ensure_crypt_mode(chunk.crypt_mode()?)?;
  75
  76             Ok(chunk)
  77         })
  78     }
  79
  80     fn read_chunk<'a>(
  81         &'a self,
  82         digest: &'a [u8; 32],
  83     ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, Error>> + Send + 'a>> {
  84         Box::pin(async move {
  85             let chunk = AsyncReadChunk::read_raw_chunk(self, digest).await?;
  86
  87             let raw_data = chunk.decode(self.crypt_config.as_ref().map(Arc::as_ref), Some(digest))?;
  88
  89             // fixme: verify digest?
  90
  91             Ok(raw_data)
  92         })
  93     }
  94 }