client: Handle get_blob futures being polled serially

- Add documentation for how it worked before
- Wrap the reader in a `.take()` which will handle the case where
  the caller polls the futures serially
- Change one example to do it that way to test it

Closes: #71
Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

examples/client.rs

@@ -94,10 +94,13 @@ async fn fetch_container_to_devnull(o: GetMetadataOpts) -> Result<()> {
     for layer in manifest.layers() {
         let (mut blob, driver) = proxy.get_descriptor(img, layer).await?;
         let mut devnull = tokio::io::sink();
-        let copier = tokio::io::copy(&mut blob, &mut devnull);
-        let (copier, driver) = tokio::join!(copier, driver);
-        copier?;
-        driver?;
+        // This is the preferred way to handle this:
+        //   let copier = tokio::io::copy(&mut blob, &mut devnull);
+        //   let (copier, driver) = tokio::join!(copier, driver);
+        // But in our example code here we do it serially to verify it works.
+        // ref https://github.com/containers/containers-image-proxy-rs/issues/71
+        tokio::io::copy(&mut blob, &mut devnull).await?;
+        driver.await?;
     }
     Ok(())
 }

src/imageproxy.rs

@@ -545,6 +545,11 @@ impl ImageProxy {
     /// <https://github.com/opencontainers/image-spec/blob/main/descriptor.md>
     ///
     /// The requested size and digest are verified (by the proxy process).
+    ///
+    /// Note that because of the implementation details of this function, you should
+    /// [`futures::join!`] the returned futures instead of polling one after the other. The
+    /// secondary "driver" future will only return once everything has been read from
+    /// the reader future.
     #[instrument]
     pub async fn get_blob(
         &self,
@@ -563,7 +568,9 @@ impl ImageProxy {
         let (_bloblen, fd) = self.impl_request::<i64, _, _>("GetBlob", args).await?;
         let (fd, pipeid) = fd.ok_or_else(|| Error::new_other("Missing fd from reply"))?;
         let fd = tokio::fs::File::from_std(std::fs::File::from(fd));
-        let fd = tokio::io::BufReader::new(fd);
+        // We only read up to the object size, ref https://github.com/containers/containers-image-proxy-rs/issues/71
+        // This is a fallback to handle the case where the caller polls the two futures serially.
+        let fd = tokio::io::BufReader::new(fd).take(size);
         let finish = Box::pin(self.finish_pipe(pipeid));
         Ok((fd, finish))
     }