start patching through errors in ipld

Author: dignifiedquire

ipld/blockstore/Cargo.toml

@@ -9,7 +9,6 @@ repository = "https://github.com/filecoin-project/ref-fvm"
 
 [dependencies]
 cid = { version = "0.8.2", default-features = false, features = ["serde-codec", "std"] }
-anyhow = "1.0.51"
 
 
 [dev-dependencies]

ipld/blockstore/src/lib.rs

@@ -1,6 +1,5 @@
 use std::rc::Rc;
 
-use anyhow::Result;
 use cid::{multihash, Cid};
 
 pub mod tracking;
@@ -15,26 +14,28 @@ pub use block::*;
 ///
 /// The cgo blockstore adapter implements this trait.
 pub trait Blockstore {
+    type Error: std::error::Error + std::fmt::Debug;
+
     /// Gets the block from the blockstore.
-    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>>;
+    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>, Self::Error>;
 
     /// Put a block with a pre-computed cid.
     ///
     /// If you don't yet know the CID, use put. Some blockstores will re-compute the CID internally
     /// even if you provide it.
     ///
     /// If you _do_ already know the CID, use this method as some blockstores _won't_ recompute it.
-    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<()>;
+    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<(), Self::Error>;
 
     /// Checks if the blockstore has the specified block.
-    fn has(&self, k: &Cid) -> Result<bool> {
+    fn has(&self, k: &Cid) -> Result<bool, Self::Error> {
         Ok(self.get(k)?.is_some())
     }
 
     /// Puts the block into the blockstore, computing the hash with the specified multicodec.
     ///
     /// By default, this defers to put.
-    fn put<D>(&self, mh_code: multihash::Code, block: &Block<D>) -> Result<Cid>
+    fn put<D>(&self, mh_code: multihash::Code, block: &Block<D>) -> Result<Cid, Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
@@ -55,7 +56,7 @@ pub trait Blockstore {
     /// let blocks = vec![Block::new(0x55, vec![0, 1, 2])];
     /// bs.put_many(blocks.iter().map(|b| (Blake2b256, b.into()))).unwrap();
     /// ```
-    fn put_many<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
@@ -68,7 +69,7 @@ pub trait Blockstore {
     /// Bulk-put pre-keyed blocks into the blockstore.
     ///
     /// By default, this defers to put_keyed.
-    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
@@ -82,34 +83,36 @@ pub trait Blockstore {
 }
 
 pub trait Buffered: Blockstore {
-    fn flush(&self, root: &Cid) -> Result<()>;
+    fn flush(&self, root: &Cid) -> Result<(), Self::Error>;
 }
 
 impl<BS> Blockstore for &BS
 where
     BS: Blockstore,
 {
-    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>> {
+    type Error = BS::Error;
+
+    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>, Self::Error> {
         (*self).get(k)
     }
 
-    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<()> {
+    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<(), Self::Error> {
         (*self).put_keyed(k, block)
     }
 
-    fn has(&self, k: &Cid) -> Result<bool> {
+    fn has(&self, k: &Cid) -> Result<bool, Self::Error> {
         (*self).has(k)
     }
 
-    fn put<D>(&self, mh_code: multihash::Code, block: &Block<D>) -> Result<Cid>
+    fn put<D>(&self, mh_code: multihash::Code, block: &Block<D>) -> Result<Cid, Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
     {
         (*self).put(mh_code, block)
     }
 
-    fn put_many<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
@@ -118,7 +121,7 @@ where
         (*self).put_many(blocks)
     }
 
-    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
@@ -132,27 +135,29 @@ impl<BS> Blockstore for Rc<BS>
 where
     BS: Blockstore,
 {
-    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>> {
+    type Error = BS::Error;
+
+    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>, Self::Error> {
         (**self).get(k)
     }
 
-    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<()> {
+    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<(), Self::Error> {
         (**self).put_keyed(k, block)
     }
 
-    fn has(&self, k: &Cid) -> Result<bool> {
+    fn has(&self, k: &Cid) -> Result<bool, Self::Error> {
         (**self).has(k)
     }
 
-    fn put<D>(&self, mh_code: multihash::Code, block: &Block<D>) -> Result<Cid>
+    fn put<D>(&self, mh_code: multihash::Code, block: &Block<D>) -> Result<Cid, Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
     {
         (**self).put(mh_code, block)
     }
 
-    fn put_many<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
@@ -161,7 +166,7 @@ where
         (**self).put_many(blocks)
     }
 
-    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,

ipld/blockstore/src/memory.rs

@@ -1,7 +1,7 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
+use std::convert::Infallible;
 
-use anyhow::Result;
 use cid::Cid;
 
 use super::Blockstore;
@@ -18,15 +18,17 @@ impl MemoryBlockstore {
 }
 
 impl Blockstore for MemoryBlockstore {
-    fn has(&self, k: &Cid) -> Result<bool> {
+    type Error = Infallible;
+
+    fn has(&self, k: &Cid) -> Result<bool, Self::Error> {
         Ok(self.blocks.borrow().contains_key(k))
     }
 
-    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>> {
+    fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>, Self::Error> {
         Ok(self.blocks.borrow().get(k).cloned())
     }
 
-    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<()> {
+    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<(), Self::Error> {
         self.blocks.borrow_mut().insert(*k, block.into());
         Ok(())
     }

ipld/blockstore/src/tracking.rs

@@ -2,7 +2,6 @@
 
 use std::cell::RefCell;
 
-use anyhow::Result;
 use cid::multihash::{self, Code};
 use cid::Cid;
 
@@ -46,7 +45,9 @@ impl<BS> Blockstore for TrackingBlockstore<BS>
 where
     BS: Blockstore,
 {
-    fn get(&self, cid: &Cid) -> Result<Option<Vec<u8>>> {
+    type Error = BS::Error;
+
+    fn get(&self, cid: &Cid) -> Result<Option<Vec<u8>>, Self::Error> {
         let mut stats = self.stats.borrow_mut();
         stats.r += 1;
         let bytes = self.base.get(cid)?;
@@ -55,12 +56,13 @@ where
         }
         Ok(bytes)
     }
-    fn has(&self, cid: &Cid) -> Result<bool> {
+
+    fn has(&self, cid: &Cid) -> Result<bool, Self::Error> {
         self.stats.borrow_mut().r += 1;
         self.base.has(cid)
     }
 
-    fn put<D>(&self, code: Code, block: &Block<D>) -> Result<Cid>
+    fn put<D>(&self, code: Code, block: &Block<D>) -> Result<Cid, Self::Error>
     where
         D: AsRef<[u8]>,
     {
@@ -70,14 +72,14 @@ where
         self.base.put(code, block)
     }
 
-    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<()> {
+    fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<(), Self::Error> {
         let mut stats = self.stats.borrow_mut();
         stats.w += 1;
         stats.bw += block.len();
         self.base.put_keyed(k, block)
     }
 
-    fn put_many<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,
@@ -91,7 +93,7 @@ where
         Ok(())
     }
 
-    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<()>
+    fn put_many_keyed<D, I>(&self, blocks: I) -> Result<(), Self::Error>
     where
         Self: Sized,
         D: AsRef<[u8]>,

ipld/encoding/Cargo.toml

@@ -15,8 +15,7 @@ serde_ipld_dagcbor = "0.1.2"
 serde_tuple = "0.5"
 serde_repr = "0.1"
 cid = { version = "0.8.2", default-features = false, features = ["serde-codec", "std"] }
-thiserror = "1.0"
-anyhow = "1.0.56"
+thiserror = "1.0.30"
 fvm_ipld_blockstore = { version = "0.1", path = "../blockstore" }
 
 [features]

ipld/encoding/src/cbor_store.rs

@@ -4,14 +4,22 @@ use serde::{de, ser};
 
 use crate::DAG_CBOR;
 
+#[derive(thiserror::Error, Debug)]
+pub enum Error<BS: Blockstore> {
+    #[error("blockstore: {0}")]
+    Blockstore(BS::Error),
+    #[error("encoding: {0}")]
+    Encoding(#[from] crate::errors::Error),
+}
+
 /// Wrapper for database to handle inserting and retrieving ipld data with Cids
 pub trait CborStore: Blockstore + Sized {
     /// Get typed object from block store by Cid.
-    fn get_cbor<T>(&self, cid: &Cid) -> anyhow::Result<Option<T>>
+    fn get_cbor<T>(&self, cid: &Cid) -> Result<Option<T>, Error<Self>>
     where
         T: de::DeserializeOwned,
     {
-        match self.get(cid)? {
+        match self.get(cid).map_err(Error::Blockstore)? {
             Some(bz) => {
                 let res = crate::from_slice(&bz)?;
                 Ok(Some(res))
@@ -21,7 +29,7 @@ pub trait CborStore: Blockstore + Sized {
     }
 
     /// Put an object in the block store and return the Cid identifier.
-    fn put_cbor<S>(&self, obj: &S, code: multihash::Code) -> anyhow::Result<Cid>
+    fn put_cbor<S>(&self, obj: &S, code: multihash::Code) -> Result<Cid, Error<Self>>
     where
         S: ser::Serialize,
     {
@@ -33,6 +41,7 @@ pub trait CborStore: Blockstore + Sized {
                 data: &bytes,
             },
         )
+        .map_err(Error::Blockstore)
     }
 }
 

ipld/encoding/src/lib.rs

@@ -13,7 +13,7 @@ pub use serde_bytes;
 
 pub use self::bytes::*;
 pub use self::cbor::*;
-pub use self::cbor_store::CborStore;
+pub use self::cbor_store::{CborStore, Error as CborStoreError};
 pub use self::errors::*;
 pub use self::vec::*;
 

ipld/hamt/Cargo.toml

@@ -17,7 +17,6 @@ thiserror = "1.0"
 sha2 = "0.10"
 once_cell = "1.5"
 forest_hash_utils = "0.1"
-anyhow = "1.0.51"
 libipld-core = { version = "0.13.1", features = ["serde-codec"] }
 fvm_ipld_encoding = { version = "0.1", path = "../encoding" }
 fvm_ipld_blockstore = { version = "0.1", path = "../blockstore" }

ipld/hamt/src/error.rs

@@ -3,12 +3,13 @@
 
 use std::error::Error as StdError;
 
-use fvm_ipld_encoding::Error as EncodingError;
+use fvm_ipld_blockstore::Blockstore;
+use fvm_ipld_encoding::{CborStore, CborStoreError, Error as EncodingError};
 use thiserror::Error;
 
 /// HAMT Error
 #[derive(Debug, Error)]
-pub enum Error {
+pub enum Error<BS: Blockstore> {
     /// Maximum depth error
     #[error("Maximum depth reached")]
     MaxDepth,
@@ -21,39 +22,8 @@ pub enum Error {
     /// Cid not found in store error
     #[error("Cid ({0}) did not match any in database")]
     CidNotFound(String),
-    // TODO: This should be something like "internal" or "io". And we shouldn't have both this and
-    // "other"; they serve the same purpose.
-    /// Dynamic error for when the error needs to be forwarded as is.
-    #[error("{0}")]
-    Dynamic(anyhow::Error),
-}
-
-impl From<String> for Error {
-    fn from(e: String) -> Self {
-        Self::Dynamic(anyhow::anyhow!(e))
-    }
-}
-
-impl From<&'static str> for Error {
-    fn from(e: &'static str) -> Self {
-        Self::Dynamic(anyhow::anyhow!(e))
-    }
-}
-
-impl From<anyhow::Error> for Error {
-    fn from(e: anyhow::Error) -> Self {
-        e.downcast::<Error>().unwrap_or_else(Self::Dynamic)
-    }
-}
-
-impl From<EncodingError> for Error {
-    fn from(e: EncodingError) -> Self {
-        Self::Dynamic(anyhow::anyhow!(e))
-    }
-}
-
-impl From<Box<dyn StdError + Send + Sync>> for Error {
-    fn from(e: Box<dyn StdError + Send + Sync>) -> Self {
-        Self::Dynamic(anyhow::anyhow!(e))
-    }
+    #[error("blockstore {0}")]
+    Blockstore(BS::Error),
+    #[error("encoding error {0}")]
+    Encoding(#[from] EncodingError),
 }