convert ipld/hamt

Author: dignifiedquire

ipld/hamt/src/error.rs

@@ -1,21 +1,15 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use std::error::Error as StdError;
-
 use fvm_ipld_blockstore::Blockstore;
-use fvm_ipld_encoding::{CborStore, CborStoreError, Error as EncodingError};
+use fvm_ipld_encoding::{CborStoreError, Error as EncodingError};
 use thiserror::Error;
 
 /// HAMT Error
 #[derive(Debug, Error)]
 pub enum Error<BS: Blockstore> {
-    /// Maximum depth error
-    #[error("Maximum depth reached")]
-    MaxDepth,
-    /// Hash bits does not support greater than 8 bit width
-    #[error("HashBits does not support retrieving more than 8 bits")]
-    InvalidHashBitLen,
+    #[error("hashbits: {0}")]
+    HashBits(#[from] HashBitsError),
     /// This should be treated as a fatal error, must have at least one pointer in node
     #[error("Invalid HAMT format, node cannot have 0 pointers")]
     ZeroPointers,
@@ -27,3 +21,36 @@ pub enum Error<BS: Blockstore> {
     #[error("encoding error {0}")]
     Encoding(#[from] EncodingError),
 }
+
+impl<BS: Blockstore> From<CborStoreError<BS>> for Error<BS> {
+    fn from(err: CborStoreError<BS>) -> Self {
+        match err {
+            CborStoreError::Blockstore(err) => Error::Blockstore(err),
+            CborStoreError::Encoding(err) => Error::Encoding(err),
+        }
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum EitherError<U, BS: Blockstore> {
+    #[error("user: {0}")]
+    User(U),
+    #[error("hamt: {0}")]
+    Hamt(#[from] Error<BS>),
+}
+
+impl<U, BS: Blockstore> From<CborStoreError<BS>> for EitherError<U, BS> {
+    fn from(err: CborStoreError<BS>) -> Self {
+        EitherError::Hamt(err.into())
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum HashBitsError {
+    /// Maximum depth error
+    #[error("Maximum depth reached")]
+    MaxDepth,
+    /// Hash bits does not support greater than 8 bit width
+    #[error("HashBits does not support retrieving more than 8 bits")]
+    InvalidLen,
+}

ipld/hamt/src/hamt.rs

@@ -12,6 +12,7 @@ use multihash::Code;
 use serde::de::DeserializeOwned;
 use serde::{Serialize, Serializer};
 
+use crate::error::EitherError;
 use crate::node::Node;
 use crate::{Error, Hash, HashAlgorithm, Sha256, DEFAULT_BIT_WIDTH};
 
@@ -82,12 +83,12 @@ where
     }
 
     /// Lazily instantiate a hamt from this root Cid.
-    pub fn load(cid: &Cid, store: BS) -> Result<Self, Error> {
+    pub fn load(cid: &Cid, store: BS) -> Result<Self, Error<BS>> {
         Self::load_with_bit_width(cid, store, DEFAULT_BIT_WIDTH)
     }
 
     /// Lazily instantiate a hamt from this root Cid with a specified bit width.
-    pub fn load_with_bit_width(cid: &Cid, store: BS, bit_width: u32) -> Result<Self, Error> {
+    pub fn load_with_bit_width(cid: &Cid, store: BS, bit_width: u32) -> Result<Self, Error<BS>> {
         match store.get_cbor(cid)? {
             Some(root) => Ok(Self {
                 root,
@@ -100,7 +101,7 @@ where
     }
 
     /// Sets the root based on the Cid of the root node using the Hamt store
-    pub fn set_root(&mut self, cid: &Cid) -> Result<(), Error> {
+    pub fn set_root(&mut self, cid: &Cid) -> Result<(), Error<BS>> {
         match self.store.get_cbor(cid)? {
             Some(root) => self.root = root,
             None => return Err(Error::CidNotFound(cid.to_string())),
@@ -136,7 +137,7 @@ where
     /// map.set(37, "b".to_string()).unwrap();
     /// map.set(37, "c".to_string()).unwrap();
     /// ```
-    pub fn set(&mut self, key: K, value: V) -> Result<Option<V>, Error>
+    pub fn set(&mut self, key: K, value: V) -> Result<Option<V>, Error<BS>>
     where
         V: PartialEq,
     {
@@ -171,7 +172,7 @@ where
     /// let c = map.set_if_absent(30, "c".to_string()).unwrap();
     /// assert_eq!(c, true);
     /// ```
-    pub fn set_if_absent(&mut self, key: K, value: V) -> Result<bool, Error>
+    pub fn set_if_absent(&mut self, key: K, value: V) -> Result<bool, Error<BS>>
     where
         V: PartialEq,
     {
@@ -200,7 +201,7 @@ where
     /// assert_eq!(map.get(&2).unwrap(), None);
     /// ```
     #[inline]
-    pub fn get<Q: ?Sized>(&self, k: &Q) -> Result<Option<&V>, Error>
+    pub fn get<Q: ?Sized>(&self, k: &Q) -> Result<Option<&V>, Error<BS>>
     where
         K: Borrow<Q>,
         Q: Hash + Eq,
@@ -232,7 +233,7 @@ where
     /// assert_eq!(map.contains_key(&2).unwrap(), false);
     /// ```
     #[inline]
-    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> Result<bool, Error>
+    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> Result<bool, Error<BS>>
     where
         K: Borrow<Q>,
         Q: Hash + Eq,
@@ -263,7 +264,7 @@ where
     /// assert_eq!(map.delete(&1).unwrap(), Some((1, "a".to_string())));
     /// assert_eq!(map.delete(&1).unwrap(), None);
     /// ```
-    pub fn delete<Q: ?Sized>(&mut self, k: &Q) -> Result<Option<(K, V)>, Error>
+    pub fn delete<Q: ?Sized>(&mut self, k: &Q) -> Result<Option<(K, V)>, Error<BS>>
     where
         K: Borrow<Q>,
         Q: Hash + Eq,
@@ -273,7 +274,7 @@ where
     }
 
     /// Flush root and return Cid for hamt
-    pub fn flush(&mut self) -> Result<Cid, Error> {
+    pub fn flush(&mut self) -> Result<Cid, Error<BS>> {
         self.root.flush(self.store.borrow())?;
         Ok(self.store.put_cbor(&self.root, Code::Blake2b256)?)
     }
@@ -301,15 +302,15 @@ where
     /// let mut total = 0;
     /// map.for_each(|_, v: &u64| {
     ///    total += v;
-    ///    Ok(())
+    ///    Ok::<(), ()>(())
     /// }).unwrap();
     /// assert_eq!(total, 3);
     /// ```
     #[inline]
-    pub fn for_each<F>(&self, mut f: F) -> Result<(), Error>
+    pub fn for_each<F, U>(&self, mut f: F) -> Result<(), EitherError<U, BS>>
     where
         V: DeserializeOwned,
-        F: FnMut(&K, &V) -> anyhow::Result<()>,
+        F: FnMut(&K, &V) -> Result<(), U>,
     {
         self.root.for_each(self.store.borrow(), &mut f)
     }

ipld/hamt/src/hash_bits.rs

@@ -3,7 +3,7 @@
 
 use std::cmp::Ordering;
 
-use crate::{Error, HashedKey};
+use crate::{HashBitsError, HashedKey};
 
 /// Helper struct which indexes and allows returning bits from a hashed key
 #[derive(Debug, Clone, Copy)]
@@ -32,12 +32,12 @@ impl<'a> HashBits<'a> {
 
     /// Returns next `i` bits of the hash and returns the value as an integer and returns
     /// Error when maximum depth is reached
-    pub fn next(&mut self, i: u32) -> Result<u32, Error> {
+    pub fn next(&mut self, i: u32) -> Result<u32, HashBitsError> {
         if i > 8 {
-            return Err(Error::InvalidHashBitLen);
+            return Err(HashBitsError::InvalidLen);
         }
         if (self.consumed + i) as usize > self.b.len() * 8 {
-            return Err(Error::MaxDepth);
+            return Err(HashBitsError::MaxDepth);
         }
         Ok(self.next_bits(i))
     }
@@ -94,11 +94,11 @@ mod tests {
         assert_eq!(hb.next(5).unwrap(), 0b01010);
         assert_eq!(hb.next(6).unwrap(), 0b111111);
         assert_eq!(hb.next(8).unwrap(), 0b11111111);
-        assert!(matches!(hb.next(9), Err(Error::InvalidHashBitLen)));
+        assert!(matches!(hb.next(9), Err(HashBitsError::InvalidLen)));
         for _ in 0..28 {
             // Iterate through rest of key to test depth
             hb.next(8).unwrap();
         }
-        assert!(matches!(hb.next(1), Err(Error::MaxDepth)));
+        assert!(matches!(hb.next(1), Err(HashBitsError::MaxDepth)));
     }
 }

ipld/hamt/src/lib.rs

@@ -21,7 +21,7 @@ mod pointer;
 pub use forest_hash_utils::{BytesKey, Hash};
 use serde::{Deserialize, Serialize};
 
-pub use self::error::Error;
+pub use self::error::*;
 pub use self::hamt::Hamt;
 pub use self::hash::*;
 pub use self::hash_algorithm::*;

ipld/hamt/src/node.rs

@@ -16,6 +16,7 @@ use super::bitfield::Bitfield;
 use super::hash_bits::HashBits;
 use super::pointer::Pointer;
 use super::{Error, Hash, HashAlgorithm, KeyValuePair, MAX_ARRAY_WIDTH};
+use crate::error::EitherError;
 
 /// Node in Hamt tree which contains bitfield of set indexes and pointers to nodes
 #[derive(Debug)]
@@ -85,7 +86,7 @@ where
         store: &S,
         bit_width: u32,
         overwrite: bool,
-    ) -> Result<(Option<V>, bool), Error>
+    ) -> Result<(Option<V>, bool), Error<S>>
     where
         V: PartialEq,
     {
@@ -107,7 +108,7 @@ where
         k: &Q,
         store: &S,
         bit_width: u32,
-    ) -> Result<Option<&V>, Error>
+    ) -> Result<Option<&V>, Error<S>>
     where
         K: Borrow<Q>,
         Q: Eq + Hash,
@@ -121,7 +122,7 @@ where
         k: &Q,
         store: &S,
         bit_width: u32,
-    ) -> Result<Option<(K, V)>, Error>
+    ) -> Result<Option<(K, V)>, Error<S>>
     where
         K: Borrow<Q>,
         Q: Eq + Hash,
@@ -135,9 +136,9 @@ where
         self.pointers.is_empty()
     }
 
-    pub(crate) fn for_each<S, F>(&self, store: &S, f: &mut F) -> Result<(), Error>
+    pub(crate) fn for_each<S, F, U>(&self, store: &S, f: &mut F) -> Result<(), EitherError<U, S>>
     where
-        F: FnMut(&K, &V) -> anyhow::Result<()>,
+        F: FnMut(&K, &V) -> Result<(), U>,
         S: Blockstore,
     {
         for p in &self.pointers {
@@ -150,7 +151,7 @@ where
                             node
                         } else {
                             #[cfg(not(feature = "ignore-dead-links"))]
-                            return Err(Error::CidNotFound(cid.to_string()));
+                            return Err(Error::CidNotFound(cid.to_string()).into());
 
                             #[cfg(feature = "ignore-dead-links")]
                             continue;
@@ -164,7 +165,7 @@ where
                 Pointer::Dirty(n) => n.for_each(store, f)?,
                 Pointer::Values(kvs) => {
                     for kv in kvs {
-                        f(kv.0.borrow(), kv.1.borrow())?;
+                        f(kv.0.borrow(), kv.1.borrow()).map_err(EitherError::User)?;
                     }
                 }
             }
@@ -178,7 +179,7 @@ where
         q: &Q,
         store: &S,
         bit_width: u32,
-    ) -> Result<Option<&KeyValuePair<K, V>>, Error>
+    ) -> Result<Option<&KeyValuePair<K, V>>, Error<S>>
     where
         K: Borrow<Q>,
         Q: Eq + Hash,
@@ -194,7 +195,7 @@ where
         depth: u64,
         key: &Q,
         store: &S,
-    ) -> Result<Option<&KeyValuePair<K, V>>, Error>
+    ) -> Result<Option<&KeyValuePair<K, V>>, Error<S>>
     where
         K: Borrow<Q>,
         Q: Eq + Hash,
@@ -244,7 +245,7 @@ where
         value: V,
         store: &S,
         overwrite: bool,
-    ) -> Result<(Option<V>, bool), Error>
+    ) -> Result<(Option<V>, bool), Error<S>>
     where
         V: PartialEq,
     {
@@ -364,7 +365,7 @@ where
         depth: u64,
         key: &Q,
         store: &S,
-    ) -> Result<Option<(K, V)>, Error>
+    ) -> Result<Option<(K, V)>, Error<S>>
     where
         K: Borrow<Q>,
         Q: Hash + Eq,
@@ -427,7 +428,7 @@ where
         }
     }
 
-    pub fn flush<S: Blockstore>(&mut self, store: &S) -> Result<(), Error> {
+    pub fn flush<S: Blockstore>(&mut self, store: &S) -> Result<(), Error<S>> {
         for pointer in &mut self.pointers {
             if let Pointer::Dirty(node) = pointer {
                 // Flush cached sub node to clear it's cache

ipld/hamt/src/pointer.rs

@@ -5,6 +5,7 @@ use std::cmp::Ordering;
 use std::convert::{TryFrom, TryInto};
 
 use cid::Cid;
+use fvm_ipld_blockstore::Blockstore;
 use libipld_core::ipld::Ipld;
 use once_cell::unsync::OnceCell;
 use serde::de::{self, DeserializeOwned};
@@ -111,7 +112,7 @@ where
 
     /// Internal method to cleanup children, to ensure consistent tree representation
     /// after deletes.
-    pub(crate) fn clean(&mut self) -> Result<(), Error> {
+    pub(crate) fn clean<BS: Blockstore>(&mut self) -> Result<(), Error<BS>> {
         match self {
             Pointer::Dirty(n) => match n.pointers.len() {
                 0 => Err(Error::ZeroPointers),

ipld/hamt/tests/hamt_tests.rs

@@ -273,7 +273,7 @@ fn for_each() {
     hamt.for_each(|k, v| {
         assert_eq!(k, v);
         count += 1;
-        Ok(())
+        Ok::<(), ()>(())
     })
     .unwrap();
     assert_eq!(count, 200);
@@ -291,7 +291,7 @@ fn for_each() {
     hamt.for_each(|k, v| {
         assert_eq!(k, v);
         count += 1;
-        Ok(())
+        Ok::<(), ()>(())
     })
     .unwrap();
     assert_eq!(count, 200);
@@ -301,7 +301,7 @@ fn for_each() {
     hamt.for_each(|k, v| {
         assert_eq!(k, v);
         count += 1;
-        Ok(())
+        Ok::<(), ()>(())
     })
     .unwrap();
     assert_eq!(count, 200);