clean up error handling

src/disk.rs

···
+use crate::drive::DriveError;
 use rusqlite::OptionalExtension;
 use std::path::PathBuf;
 
···
     }
     pub fn put_many(
         &mut self,
-        kv: impl Iterator<Item = (Vec<u8>, Vec<u8>)>,
-    ) -> rusqlite::Result<()> {
+        kv: impl Iterator<Item = Result<(Vec<u8>, Vec<u8>), DriveError>>,
+    ) -> Result<(), DriveError> {
         let tx = self.tx.as_ref().unwrap();
         let mut insert_stmt = tx.prepare_cached("INSERT INTO blocks (key, val) VALUES (?1, ?2)")?;
-        for (k, v) in kv {
+        for pair in kv {
+            let (k, v) = pair?;
             insert_stmt.execute((k, v))?;
         }
         Ok(())

src/drive.rs

···
 use tokio::io::AsyncRead;
 
 use crate::mst::{Commit, Node};
-use crate::walk::{Step, Trip, Walker};
+use crate::walk::{Step, WalkError, Walker};
 
 /// Errors that can happen while consuming and emitting blocks and records
 #[derive(Debug, thiserror::Error)]
···
     #[error("The MST block {0} could not be found")]
     MissingBlock(Cid),
     #[error("Failed to walk the mst tree: {0}")]
-    Tripped(#[from] Trip),
+    WalkError(#[from] WalkError),
     #[error("CAR file had no roots")]
     MissingRoot,
     #[error("Storage error")]
···
     BincodeEncodeError(#[from] bincode::error::EncodeError),
     #[error("Decode error: {0}")]
     BincodeDecodeError(#[from] bincode::error::DecodeError),
+    #[error("Tried to send on a closed channel")]
+    ChannelSendError, // SendError takes <T> which we don't need
+    #[error("Failed to join a task: {0}")]
+    JoinError(#[from] tokio::task::JoinError),
 }
 
 pub trait Processable: Clone + Serialize + DeserializeOwned {
···
         }
 
         // remaining possible types: node, record, other. optimistically process
-        // TODO: get the actual in-memory size to compute disk spill
         let maybe_processed = if Node::could_be(&data) {
             MaybeProcessedBlock::Raw(data)
         } else {
···
             let kvs = self
                 .mem_blocks
                 .into_iter()
-                .map(|(k, v)| (k.to_bytes(), encode(v).unwrap()));
+                .map(|(k, v)| Ok(encode(v).map(|v| (k.to_bytes(), v))?));
 
             writer.put_many(kvs)?;
 
             drop(writer); // cannot outlive access
             Ok::<_, DriveError>(access)
         })
-        .await
-        .unwrap()?;
+        .await??;
 
         let (tx, mut rx) = tokio::sync::mpsc::channel::<Vec<(Cid, MaybeProcessedBlock<T>)>>(2);
 
···
             while let Some(chunk) = rx.blocking_recv() {
                 let kvs = chunk
                     .into_iter()
-                    .map(|(k, v)| (k.to_bytes(), encode(v).unwrap()));
+                    .map(|(k, v)| Ok(encode(v).map(|v| (k.to_bytes(), v))?));
                 writer.put_many(kvs)?;
             }
 
···
             if chunk.is_empty() {
                 break;
             }
-            tx.send(chunk).await.unwrap();
+            tx.send(chunk)
+                .await
+                .map_err(|_| DriveError::ChannelSendError)?;
         }
         drop(tx);
         log::debug!("done. waiting for worker to finish...");
 
-        access = access_worker.await.unwrap()?;
+        access = access_worker.await??;
 
         log::debug!("worker finished.");
 
···
             self.access = access;
             Ok::<_, DriveError>((self, out))
         })
-        .await
-        .unwrap()?; // TODO
+        .await??;
 
         if out.is_empty() {
             Ok((self, None))
···
                 if out.is_empty() {
                     break;
                 }
-                tx.blocking_send(out).unwrap();
+                tx.blocking_send(out)
+                    .map_err(|_| DriveError::ChannelSendError)?;
             }
 
             drop(reader); // cannot outlive access

src/walk.rs

···
 
 /// Errors that can happen while walking
 #[derive(Debug, thiserror::Error)]
-pub enum Trip {
+pub enum WalkError {
     #[error("Failed to fingerprint commit block")]
     BadCommitFingerprint,
     #[error("Failed to decode commit block: {0}")]
···
         &mut self,
         blocks: &mut HashMap<Cid, MaybeProcessedBlock<T>>,
         process: impl Fn(Vec<u8>) -> T,
-    ) -> Result<Step<T>, Trip> {
+    ) -> Result<Step<T>, WalkError> {
         loop {
             let Some(need) = self.stack.last_mut() else {
                 log::trace!("tried to walk but we're actually done.");
···
                     };
 
                     let MaybeProcessedBlock::Raw(data) = block else {
-                        return Err(Trip::BadCommitFingerprint);
+                        return Err(WalkError::BadCommitFingerprint);
                     };
-                    let node =
-                        serde_ipld_dagcbor::from_slice::<Node>(&data).map_err(Trip::BadCommit)?;
+                    let node = serde_ipld_dagcbor::from_slice::<Node>(&data)
+                        .map_err(WalkError::BadCommit)?;
 
                     // found node, make sure we remember
                     self.stack.pop();
···
                 }
                 Need::Record { rkey, cid } => {
                     log::trace!("need record {cid:?}");
+                    // note that we cannot *remove* a record block, sadly, since
+                    // there can be multiple rkeys pointing to the same cid.
                     let Some(data) = blocks.get_mut(cid) else {
-                        log::trace!("record block not found, resting");
                         return Ok(Step::Missing(*cid));
                     };
                     let rkey = rkey.clone();
···
                     // found node, make sure we remember
                     self.stack.pop();
 
-                    log::trace!("emitting a block as a step. depth={}", self.stack.len());
-
                     // rkeys *must* be in order or else the tree is invalid (or
                     // we have a bug)
                     if rkey <= self.prev {
···
         &mut self,
         reader: &mut SqliteReader,
         process: impl Fn(Vec<u8>) -> T,
-    ) -> Result<Step<T>, Trip> {
+    ) -> Result<Step<T>, WalkError> {
         loop {
             let Some(need) = self.stack.last_mut() else {
                 log::trace!("tried to walk but we're actually done.");
···
                     let block: MaybeProcessedBlock<T> = crate::drive::decode(&block_bytes)?;
 
                     let MaybeProcessedBlock::Raw(data) = block else {
-                        return Err(Trip::BadCommitFingerprint);
+                        return Err(WalkError::BadCommitFingerprint);
                     };
-                    let node =
-                        serde_ipld_dagcbor::from_slice::<Node>(&data).map_err(Trip::BadCommit)?;
+                    let node = serde_ipld_dagcbor::from_slice::<Node>(&data)
+                        .map_err(WalkError::BadCommit)?;
 
                     // found node, make sure we remember
                     self.stack.pop();
 
                     // queue up work on the found node next
-                    push_from_node(&mut self.stack, &node, depth).map_err(Trip::MstError)?;
+                    push_from_node(&mut self.stack, &node, depth).map_err(WalkError::MstError)?;
                 }
                 Need::Record { rkey, cid } => {
                     log::trace!("need record {cid:?}");