fix: make other tests pass again

Author: Frando

src/api/blobs.rs

@@ -302,6 +302,7 @@ impl Blobs {
             ExportBaoRequest {
                 hash: hash.into(),
                 ranges: ranges.into(),
+                create_if_missing: false,
             },
             32,
         )

src/api/proto.rs

@@ -222,6 +222,7 @@ pub struct ObserveRequest {
 pub struct ExportBaoRequest {
     pub hash: Hash,
     pub ranges: ChunkRanges,
+    pub create_if_missing: bool,
 }
 
 /// Export the given ranges as chunkks, without validation.

src/api/remote.rs

@@ -10,7 +10,7 @@ use nested_enum_utils::common_fields;
 use ref_cast::RefCast;
 use snafu::{Backtrace, IntoError, Snafu};
 
-use super::blobs::Bitfield;
+use super::blobs::{Bitfield, ExportBaoOptions};
 use crate::{
     api::{blobs::WriteProgress, ApiClient},
     get::{fsm::DecodeError, BadRequestSnafu, GetError, GetResult, LocalFailureSnafu, Stats},
@@ -159,7 +159,7 @@ impl PushProgress {
 
 async fn just_result<S, R>(stream: S) -> Option<R>
 where
-    S: Stream,
+    S: Stream<Item: std::fmt::Debug>,
     R: TryFrom<S::Item>,
 {
     tokio::pin!(stream);
@@ -417,7 +417,12 @@ impl Remote {
         let root = request.hash;
         let bitfield = self.store().observe(root).await?;
         let children = if !request.ranges.is_blob() {
-            let bao = self.store().export_bao(root, bitfield.ranges.clone());
+            let opts = ExportBaoOptions {
+                hash: root,
+                ranges: bitfield.ranges.clone(),
+                create_if_missing: true,
+            };
+            let bao = self.store().export_bao_with_opts(opts, 32);
             let mut by_index = BTreeMap::new();
             let mut stream = bao.hashes_with_index();
             while let Some(item) = stream.next().await {

src/store/fs.rs

@@ -305,6 +305,14 @@ impl HashContext {
         Ok(())
     }
 
+    pub async fn get_maybe_create(&self, hash: Hash, create: bool) -> api::Result<BaoFileHandle> {
+        if create {
+            self.get_or_create(hash).await
+        } else {
+            self.get(hash).await
+        }
+    }
+
     pub async fn get(&self, hash: Hash) -> api::Result<BaoFileHandle> {
         if hash == Hash::EMPTY {
             return Ok(self.ctx.empty.clone());
@@ -1020,7 +1028,7 @@ async fn export_ranges_impl(
 
 #[instrument(skip_all, fields(hash = %cmd.hash_short()))]
 async fn export_bao(mut cmd: ExportBaoMsg, ctx: HashContext) {
-    match ctx.get(cmd.hash).await {
+    match ctx.get_maybe_create(cmd.hash, cmd.create_if_missing).await {
         Ok(handle) => {
             if let Err(cause) = export_bao_impl(cmd.inner, &mut cmd.tx, handle).await {
                 cmd.tx
@@ -1044,7 +1052,7 @@ async fn export_bao_impl(
     tx: &mut mpsc::Sender<EncodedItem>,
     handle: BaoFileHandle,
 ) -> anyhow::Result<()> {
-    let ExportBaoRequest { ranges, hash } = cmd;
+    let ExportBaoRequest { ranges, hash, .. } = cmd;
     debug_assert!(handle.hash() == hash, "hash mismatch");
     let outboard = handle.outboard()?;
     let size = outboard.tree.size();

src/store/mem.rs

@@ -117,6 +117,7 @@ impl MemStore {
                 state: State {
                     data: HashMap::new(),
                     tags: BTreeMap::new(),
+                    empty_hash: BaoFileHandle::new_partial(Hash::EMPTY),
                 },
                 options: Arc::new(Options::default()),
                 temp_tags: Default::default(),
@@ -189,15 +190,24 @@ impl Actor {
                 self.spawn(import_path(cmd));
             }
             Command::ExportBao(ExportBaoMsg {
-                inner: ExportBaoRequest { hash, ranges },
+                inner:
+                    ExportBaoRequest {
+                        hash,
+                        ranges,
+                        create_if_missing,
+                    },
                 tx,
                 ..
             }) => {
-                let entry = self.state.data.get(&hash).cloned();
+                let entry = if create_if_missing {
+                    Some(self.get_or_create_entry(hash))
+                } else {
+                    self.get(&hash)
+                };
                 self.spawn(export_bao(entry, ranges, tx))
             }
             Command::ExportPath(cmd) => {
-                let entry = self.state.data.get(&cmd.hash).cloned();
+                let entry = self.get(&cmd.hash);
                 self.spawn(export_path(entry, cmd));
             }
             Command::DeleteTags(cmd) => {
@@ -329,7 +339,7 @@ impl Actor {
                     tx,
                     ..
                 } = cmd;
-                let res = match self.state.data.get(&hash) {
+                let res = match self.get(&hash) {
                     None => api::blobs::BlobStatus::NotFound,
                     Some(x) => {
                         let bitfield = x.0.state.borrow().bitfield();
@@ -371,7 +381,7 @@ impl Actor {
                 cmd.tx.send(Ok(())).await.ok();
             }
             Command::ExportRanges(cmd) => {
-                let entry = self.state.data.get(&cmd.hash).cloned();
+                let entry = self.get(&cmd.hash);
                 self.spawn(export_ranges(cmd, entry));
             }
             Command::SyncDb(SyncDbMsg { tx, .. }) => {
@@ -384,12 +394,24 @@ impl Actor {
         None
     }
 
+    fn get(&mut self, hash: &Hash) -> Option<BaoFileHandle> {
+        if *hash == Hash::EMPTY {
+            Some(self.state.empty_hash.clone())
+        } else {
+            self.state.data.get(hash).cloned()
+        }
+    }
+
     fn get_or_create_entry(&mut self, hash: Hash) -> BaoFileHandle {
-        self.state
-            .data
-            .entry(hash)
-            .or_insert_with(|| BaoFileHandle::new_partial(hash))
-            .clone()
+        if hash == Hash::EMPTY {
+            self.state.empty_hash.clone()
+        } else {
+            self.state
+                .data
+                .entry(hash)
+                .or_insert_with(|| BaoFileHandle::new_partial(hash))
+                .clone()
+        }
     }
 
     async fn create_temp_tag(&mut self, cmd: CreateTempTagMsg) {
@@ -839,6 +861,7 @@ impl Outboard for OutboardReader {
 struct State {
     data: HashMap<Hash, BaoFileHandle>,
     tags: BTreeMap<Tag, HashAndFormat>,
+    empty_hash: BaoFileHandle,
 }
 
 #[derive(Debug, derive_more::From)]

src/store/readonly_mem.rs

@@ -117,7 +117,7 @@ impl Actor {
                 });
             }
             Command::ExportBao(ExportBaoMsg {
-                inner: ExportBaoRequest { hash, ranges },
+                inner: ExportBaoRequest { hash, ranges, .. },
                 tx,
                 ..
             }) => {