convert ipld/amt

Author: dignifiedquire

ipld/amt/Cargo.toml

@@ -14,7 +14,6 @@ thiserror = "1.0"
 once_cell = "1.5"
 ahash = { version = "0.7", optional = true }
 itertools = "0.10"
-anyhow = "1.0.51"
 fvm_ipld_blockstore = { version = "0.1", path = "../blockstore" }
 fvm_ipld_encoding = { version = "0.1", path = "../encoding" }
 

ipld/amt/src/amt.rs

@@ -1,7 +1,6 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use anyhow::anyhow;
 use cid::multihash::Code;
 use cid::Cid;
 use fvm_ipld_blockstore::Blockstore;
@@ -11,6 +10,7 @@ use fvm_ipld_encoding::CborStore;
 use itertools::sorted;
 
 use super::ValueMut;
+use crate::error::EitherError;
 use crate::node::{CollapsedNode, Link};
 use crate::{
     init_sized_vec, nodes_for_height, Error, Node, Root, DEFAULT_BIT_WIDTH, MAX_HEIGHT, MAX_INDEX,
@@ -72,7 +72,7 @@ where
     }
 
     /// Constructs an AMT with a blockstore and a Cid of the root of the AMT
-    pub fn load(cid: &Cid, block_store: BS) -> Result<Self, Error> {
+    pub fn load(cid: &Cid, block_store: BS) -> Result<Self, Error<BS>> {
         // Load root bytes from database
         let root: Root<V> = block_store
             .get_cbor(cid)?
@@ -97,7 +97,10 @@ where
     }
 
     /// Generates an AMT with block store and array of cbor marshallable objects and returns Cid
-    pub fn new_from_iter(block_store: BS, vals: impl IntoIterator<Item = V>) -> Result<Cid, Error> {
+    pub fn new_from_iter(
+        block_store: BS,
+        vals: impl IntoIterator<Item = V>,
+    ) -> Result<Cid, Error<BS>> {
         let mut t = Self::new(block_store);
 
         t.batch_set(vals)?;
@@ -106,7 +109,7 @@ where
     }
 
     /// Get value at index of AMT
-    pub fn get(&self, i: u64) -> Result<Option<&V>, Error> {
+    pub fn get(&self, i: u64) -> Result<Option<&V>, Error<BS>> {
         if i > MAX_INDEX {
             return Err(Error::OutOfRange(i));
         }
@@ -121,7 +124,7 @@ where
     }
 
     /// Set value at index
-    pub fn set(&mut self, i: u64, val: V) -> Result<(), Error> {
+    pub fn set(&mut self, i: u64, val: V) -> Result<(), Error<BS>> {
         if i > MAX_INDEX {
             return Err(Error::OutOfRange(i));
         }
@@ -163,7 +166,7 @@ where
 
     /// Batch set (naive for now)
     // TODO Implement more efficient batch set to not have to traverse tree and keep cache for each
-    pub fn batch_set(&mut self, vals: impl IntoIterator<Item = V>) -> Result<(), Error> {
+    pub fn batch_set(&mut self, vals: impl IntoIterator<Item = V>) -> Result<(), Error<BS>> {
         for (i, val) in (0u64..).zip(vals) {
             self.set(i, val)?;
         }
@@ -172,7 +175,7 @@ where
     }
 
     /// Delete item from AMT at index
-    pub fn delete(&mut self, i: u64) -> Result<Option<V>, Error> {
+    pub fn delete(&mut self, i: u64) -> Result<Option<V>, Error<BS>> {
         if i > MAX_INDEX {
             return Err(Error::OutOfRange(i));
         }
@@ -243,23 +246,23 @@ where
         &mut self,
         iter: impl IntoIterator<Item = u64>,
         strict: bool,
-    ) -> Result<bool, Error> {
+    ) -> Result<bool, Error<BS>> {
         // TODO: optimize this
         let mut modified = false;
 
         // Iterate sorted indices. Sorted to safely optimize later.
         for i in sorted(iter) {
             let found = self.delete(i)?.is_none();
             if strict && found {
-                return Err(anyhow!("no such index {} in Amt for batch delete", i).into());
+                return Err(Error::BatchDelteNotFound(i));
             }
             modified |= found;
         }
         Ok(modified)
     }
 
     /// flush root and return Cid used as key in block store
-    pub fn flush(&mut self) -> Result<Cid, Error> {
+    pub fn flush(&mut self) -> Result<Cid, Error<BS>> {
         self.root.node.flush(&self.block_store)?;
         Ok(self.block_store.put_cbor(&self.root, Code::Blake2b256)?)
     }
@@ -283,14 +286,14 @@ where
     /// let mut values: Vec<(u64, String)> = Vec::new();
     /// map.for_each(|i, v| {
     ///    values.push((i, v.clone()));
-    ///    Ok(())
+    ///    Ok::<_, ()>(())
     /// }).unwrap();
     /// assert_eq!(&values, &[(1, "One".to_owned()), (4, "Four".to_owned())]);
     /// ```
     #[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
-        F: FnMut(u64, &V) -> anyhow::Result<()>,
+        F: FnMut(u64, &V) -> Result<(), U>,
     {
         self.for_each_while(|i, x| {
             f(i, x)?;
@@ -300,9 +303,9 @@ where
 
     /// Iterates over each value in the Amt and runs a function on the values, for as long as that
     /// function keeps returning `true`.
-    pub fn for_each_while<F>(&self, mut f: F) -> Result<(), Error>
+    pub fn for_each_while<F, U>(&self, mut f: F) -> Result<(), EitherError<U, BS>>
     where
-        F: FnMut(u64, &V) -> anyhow::Result<bool>,
+        F: FnMut(u64, &V) -> Result<bool, U>,
     {
         self.root
             .node
@@ -318,10 +321,10 @@ where
 
     /// Iterates over each value in the Amt and runs a function on the values that allows modifying
     /// each value.
-    pub fn for_each_mut<F>(&mut self, mut f: F) -> Result<(), Error>
+    pub fn for_each_mut<F, U>(&mut self, mut f: F) -> Result<(), EitherError<U, BS>>
     where
         V: Clone,
-        F: FnMut(u64, &mut ValueMut<'_, V>) -> anyhow::Result<()>,
+        F: FnMut(u64, &mut ValueMut<'_, V>) -> Result<(), U>,
     {
         self.for_each_while_mut(|i, x| {
             f(i, x)?;
@@ -331,12 +334,12 @@ where
 
     /// Iterates over each value in the Amt and runs a function on the values that allows modifying
     /// each value, for as long as that function keeps returning `true`.
-    pub fn for_each_while_mut<F>(&mut self, mut f: F) -> Result<(), Error>
+    pub fn for_each_while_mut<F, U>(&mut self, mut f: F) -> Result<(), EitherError<U, BS>>
     where
         // TODO remove clone bound when go-interop doesn't require it.
         // (If needed without, this bound can be removed by duplicating function signatures)
         V: Clone,
-        F: FnMut(u64, &mut ValueMut<'_, V>) -> anyhow::Result<bool>,
+        F: FnMut(u64, &mut ValueMut<'_, V>) -> Result<bool, U>,
     {
         #[cfg(not(feature = "go-interop"))]
         {

ipld/amt/src/error.rs

@@ -1,16 +1,14 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use std::error::Error as StdError;
-
-use anyhow::anyhow;
 use cid::Error as CidError;
-use fvm_ipld_encoding::Error as EncodingError;
+use fvm_ipld_blockstore::Blockstore;
+use fvm_ipld_encoding::{CborStoreError, Error as EncodingError};
 use thiserror::Error;
 
 /// AMT Error
 #[derive(Debug, Error)]
-pub enum Error {
+pub enum Error<BS: Blockstore> {
     /// Index referenced it above arbitrary max set
     #[error("index {0} out of range for the amt")]
     OutOfRange(u64),
@@ -20,49 +18,65 @@ pub enum Error {
     /// Error generating a Cid for data
     #[error(transparent)]
     Cid(#[from] CidError),
-    /// Error when trying to serialize an AMT without a flushed cache
-    #[error("Tried to serialize without saving cache, run flush() on Amt before serializing")]
-    Cached,
     /// Serialized vector less than number of bits set
     #[error("Vector length does not match bitmap")]
     InvalidVecLength,
-    /// Invalid formatted serialized node.
-    #[error("Serialized node cannot contain both links and values")]
-    LinksAndValues,
     /// Cid not found in store error
     #[error("Cid ({0}) did not match any in database")]
     CidNotFound(String),
-    /// Dynamic error for when the error needs to be forwarded as is.
     #[error("{0}")]
-    Dynamic(anyhow::Error),
+    CollapsedNode(#[from] CollapsedNodeError),
+    #[error("no such index {0} in Amt for batch delete")]
+    BatchDelteNotFound(u64),
+    #[error("blockstore {0}")]
+    Blockstore(BS::Error),
+    #[error("encoding error {0}")]
+    Encoding(#[from] EncodingError),
 }
 
-impl From<String> for Error {
-    fn from(e: String) -> Self {
-        Self::Dynamic(anyhow::anyhow!(e))
+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),
+        }
     }
 }
 
-impl From<&'static str> for Error {
-    fn from(e: &'static str) -> Self {
-        Self::Dynamic(anyhow::anyhow!(e))
-    }
+#[derive(Debug, Error)]
+pub enum EitherError<U, BS: Blockstore> {
+    #[error("user: {0}")]
+    User(U),
+    #[error("hamt: {0}")]
+    Hamt(#[from] Error<BS>),
 }
 
-impl From<anyhow::Error> for Error {
-    fn from(e: anyhow::Error) -> Self {
-        e.downcast::<Error>().unwrap_or_else(Self::Dynamic)
+impl<U, BS: Blockstore> From<CborStoreError<BS>> for EitherError<U, BS> {
+    fn from(err: CborStoreError<BS>) -> Self {
+        EitherError::Hamt(err.into())
     }
 }
 
-impl From<EncodingError> for Error {
-    fn from(e: EncodingError) -> Self {
-        Self::Dynamic(anyhow!(e))
-    }
+#[derive(Debug, Error)]
+pub enum CollapsedNodeError {
+    #[error("expected bitfield of length {0}, found bitfield with length {1}")]
+    LengthMissmatch(usize, usize),
+    #[error("Bitmap contained more set bits than links provided")]
+    MoreBitsThanLinks,
+    #[error("Bitmap contained less set bits than links provided")]
+    LessBitsThanLinks,
+    #[error("Bitmap contained more set bits than values provided")]
+    MoreBitsThanValues,
+    #[error("Bitmap contained less set bits than values provided")]
+    LessBitsThanValues,
+    /// Invalid formatted serialized node.
+    #[error("Serialized node cannot contain both links and values")]
+    LinksAndValues,
 }
 
-impl From<Box<dyn StdError + Send + Sync>> for Error {
-    fn from(e: Box<dyn StdError + Send + Sync>) -> Self {
-        Self::Dynamic(anyhow!(e))
-    }
+#[derive(Debug, Error)]
+pub enum SerdeError {
+    /// Error when trying to serialize an AMT without a flushed cache
+    #[error("Tried to serialize without saving cache, run flush() on Amt before serializing")]
+    Cached,
 }