add error management in the implementation

src/database/abstraction.rs

@@ -473,34 +473,38 @@ impl Tree for PersyTree {
     }
 
     fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + Sync + 'a> {
-        let result = Box::new(
+        let iter = self.persy.range::<ByteVec, ByteVec, _>(&self.name, ..);
-            self.persy
+        match iter {
-                .range::<ByteVec, ByteVec, _>(&self.name, ..)
+            Ok(iter) => {
-                .unwrap()
+                let result = Box::new(iter.filter_map(|(k, v)| {
-                .filter_map(|(k, v)| {
                     v.into_iter()
                         .map(|val| (k.0.to_owned().into(), val.0.to_owned().into()))
                         .next()
-                }),
+                }));
-        );
 
                 self.write_cache.read().unwrap().iter(&self.name, result)
             }
+            Err(e) => {
+                log::warn!("error iterating {:?}", e);
+                Box::new(std::iter::empty())
+            }
+        }
+    }
 
     fn iter_from<'a>(
         &'a self,
         from: &[u8],
         backwards: bool,
     ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + 'a> {
-        let iter = if backwards {
+        let range = if backwards {
             self.persy
                 .range::<ByteVec, ByteVec, _>(&self.name, ..ByteVec(from.to_owned()))
-                .unwrap()
         } else {
             self.persy
                 .range::<ByteVec, ByteVec, _>(&self.name, ByteVec(from.to_owned())..)
-                .unwrap()
         };
+        match range {
+            Ok(iter) => {
                 let map = iter.filter_map(|(k, v)| {
                     v.into_iter()
                         .map(|val| (k.0.to_owned().into(), val.0.to_owned().into()))
@@ -517,6 +521,12 @@ impl Tree for PersyTree {
                     .unwrap()
                     .iter_from(&self.name, from, backwards, result)
             }
+            Err(e) => {
+                log::warn!("error iterating with prefix {:?}", e);
+                Box::new(std::iter::empty())
+            }
+        }
+    }
 
     fn increment(&self, key: &[u8]) -> Result<Vec<u8>> {
         let old = self.get(key)?;
@@ -530,12 +540,15 @@ impl Tree for PersyTree {
         prefix: Vec<u8>,
     ) -> Box<dyn Iterator<Item = (Box<[u8]>, Box<[u8]>)> + Send + 'a> {
         let range_prefix = ByteVec(prefix.to_owned());
+        let range = self
+            .persy
+            .range::<ByteVec, ByteVec, _>(&self.name, range_prefix..);
+
+        match range {
+            Ok(iter) => {
                 let owned_prefix = prefix.clone();
                 let result = Box::new(
-            self.persy
+                    iter.take_while(move |(k, _)| k.0.starts_with(&owned_prefix))
-                .range::<ByteVec, ByteVec, _>(&self.name, range_prefix..)
-                .unwrap()
-                .take_while(move |(k, _)| k.0.starts_with(&owned_prefix))
                         .filter_map(|(k, v)| {
                             v.into_iter()
                                 .map(|val| (k.0.to_owned().into(), val.0.to_owned().into()))
@@ -548,6 +561,12 @@ impl Tree for PersyTree {
                     .unwrap()
                     .scan_prefix(&self.name, prefix, result)
             }
+            Err(e) => {
+                log::warn!("error scanning prefix {:?}", e);
+                Box::new(std::iter::empty())
+            }
+        }
+    }
 
     fn watch_prefix<'a>(&'a self, prefix: &[u8]) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
         let (tx, rx) = tokio::sync::oneshot::channel();