errors cleanup

not generic over storage anymore, yay

src/drive.rs

···
 use tokio::io::AsyncRead;
 
 use crate::mst::{Commit, Node};
-use crate::walk::{DiskTrip, Step, Trip, Walker};
+use crate::walk::{Step, Trip, Walker};
 
 /// Errors that can happen while consuming and emitting blocks and records
 #[derive(Debug, thiserror::Error)]
···
     Tripped(#[from] Trip),
     #[error("CAR file had no roots")]
     MissingRoot,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum DiskDriveError {
-    #[error("Error from iroh_car: {0}")]
-    CarReader(#[from] iroh_car::Error),
-    #[error("Failed to decode commit block: {0}")]
-    BadBlock(#[from] serde_ipld_dagcbor::DecodeError<Infallible>),
     #[error("Storage error")]
     StorageError(#[from] rusqlite::Error),
-    #[error("The Commit block reference by the root was not found")]
-    MissingCommit,
-    #[error("The MST block {0} could not be found")]
-    MissingBlock(Cid),
     #[error("Encode error: {0}")]
     BincodeEncodeError(#[from] bincode::error::EncodeError),
     #[error("Decode error: {0}")]
     BincodeDecodeError(#[from] bincode::error::DecodeError),
-    #[error("disk tripped: {0}")]
-    DiskTripped(#[from] DiskTrip),
 }
 
 pub trait Processable: Clone + Serialize + DeserializeOwned {
···
     pub async fn finish_loading(
         mut self,
         mut store: SqliteStore,
-    ) -> Result<(Commit, BigCarReady<T>), DiskDriveError> {
+    ) -> Result<(Commit, BigCarReady<T>), DriveError> {
         // set up access for real
         let mut access = store.get_access().await?;
 
···
             writer.put_many(kvs)?;
 
             drop(writer); // cannot outlive access
-            Ok::<_, DiskDriveError>(access)
+            Ok::<_, DriveError>(access)
         })
         .await
         .unwrap()?;
···
             }
 
             drop(writer); // cannot outlive access
-            Ok::<_, DiskDriveError>(access)
+            Ok::<_, DriveError>(access)
         }); // await later
 
         // dump the rest to disk (in chunks)
···
 
         log::debug!("worker finished.");
 
-        let commit = self.commit.ok_or(DiskDriveError::MissingCommit)?;
+        let commit = self.commit.ok_or(DriveError::MissingCommit)?;
 
         let walker = Walker::new(commit.data);
 
···
     pub async fn next_chunk(
         mut self,
         n: usize,
-    ) -> Result<(Self, Option<Vec<(String, T)>>), DiskDriveError> {
+    ) -> Result<(Self, Option<Vec<(String, T)>>), DriveError> {
         let mut out = Vec::with_capacity(n);
         (self, out) = tokio::task::spawn_blocking(move || {
             let access = self.access;
···
             for _ in 0..n {
                 // walk as far as we can until we run out of blocks or find a record
                 match self.walker.disk_step(&mut reader, self.process)? {
-                    Step::Missing(cid) => return Err(DiskDriveError::MissingBlock(cid)),
+                    Step::Missing(cid) => return Err(DriveError::MissingBlock(cid)),
                     Step::Finish => break,
                     Step::Step { rkey, data } => {
                         out.push((rkey, data));
···
 
             drop(reader); // cannot outlive access
             self.access = access;
-            Ok::<_, DiskDriveError>((self, out))
+            Ok::<_, DriveError>((self, out))
         })
         .await
         .unwrap()?; // TODO
···
     ) -> Result<
         (
             tokio::sync::mpsc::Receiver<Vec<(String, T)>>,
-            tokio::task::JoinHandle<Result<(), DiskDriveError>>,
+            tokio::task::JoinHandle<Result<(), DriveError>>,
         ),
-        DiskDriveError,
+        DriveError,
     > {
         let (tx, rx) = tokio::sync::mpsc::channel::<Vec<(String, T)>>(1);
 
···
                 for _ in 0..n {
                     // walk as far as we can until we run out of blocks or find a record
                     match self.walker.disk_step(&mut reader, self.process)? {
-                        Step::Missing(cid) => return Err(DiskDriveError::MissingBlock(cid)),
+                        Step::Missing(cid) => return Err(DriveError::MissingBlock(cid)),
                         Step::Finish => break,
                         Step::Step { rkey, data } => {
                             out.push((rkey, data));

src/walk.rs

···
 /// Errors that can happen while walking
 #[derive(Debug, thiserror::Error)]
 pub enum Trip {
-    #[error("empty mst nodes are not allowed")]
-    NodeEmpty,
     #[error("Failed to fingerprint commit block")]
     BadCommitFingerprint,
     #[error("Failed to decode commit block: {0}")]
     BadCommit(#[from] serde_ipld_dagcbor::DecodeError<Infallible>),
     #[error("Action node error: {0}")]
     MstError(#[from] MstError),
-    #[error("Encountered an rkey out of order while walking the MST")]
-    RkeyOutOfOrder,
-}
-
-/// Errors that can happen while walking
-#[derive(Debug, thiserror::Error)]
-pub enum DiskTrip {
-    #[error("tripped: {0}")]
-    Trip(#[from] Trip),
     #[error("storage error: {0}")]
     StorageError(#[from] rusqlite::Error),
     #[error("Decode error: {0}")]
···
     LostDepth,
     #[error("MST depth underflow: depth-0 node with child trees")]
     DepthUnderflow,
+    #[error("Encountered an rkey out of order while walking the MST")]
+    RkeyOutOfOrder,
 }
 
 /// Walker outputs
···
                     // rkeys *must* be in order or else the tree is invalid (or
                     // we have a bug)
                     if rkey <= self.prev {
-                        return Err(Trip::RkeyOutOfOrder);
+                        return Err(MstError::RkeyOutOfOrder)?;
                     }
                     self.prev = rkey.clone();
 
···
         &mut self,
         reader: &mut SqliteReader,
         process: impl Fn(Vec<u8>) -> T,
-    ) -> Result<Step<T>, DiskTrip> {
+    ) -> Result<Step<T>, Trip> {
         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.into());
+                        return Err(Trip::BadCommitFingerprint);
                     };
                     let node =
                         serde_ipld_dagcbor::from_slice::<Node>(&data).map_err(Trip::BadCommit)?;
···
                     // rkeys *must* be in order or else the tree is invalid (or
                     // we have a bug)
                     if rkey <= self.prev {
-                        return Err(DiskTrip::Trip(Trip::RkeyOutOfOrder));
+                        return Err(MstError::RkeyOutOfOrder)?;
                     }
                     self.prev = rkey.clone();