Use BlobError for get_size return

src/ledger.rs

@@ -1,11 +1,12 @@
 //! The `ledger` module provides functions for parallel verification of the
 //! Proof of History ledger.
 
-use bincode::{self, deserialize, serialize_into};
+use bincode::{deserialize, serialize_into};
 use entry::Entry;
 use hash::Hash;
 use packet::{self, SharedBlob, BLOB_DATA_SIZE};
 use rayon::prelude::*;
+use result::{Error, Result};
 use std::collections::VecDeque;
 use std::io::Cursor;
 use transaction::Transaction;
@@ -51,21 +52,21 @@ impl Block for [Entry] {
     }
 }
 
-pub fn reconstruct_entries_from_blobs(blobs: VecDeque<SharedBlob>) -> bincode::Result<Vec<Entry>> {
+pub fn reconstruct_entries_from_blobs(blobs: VecDeque<SharedBlob>) -> Result<Vec<Entry>> {
     let mut entries: Vec<Entry> = Vec::with_capacity(blobs.len());
 
     for blob in blobs {
         let entry = {
             let msg = blob.read().unwrap();
-            let msg_size = msg.get_size();
+            let msg_size = msg.get_size()?;
             deserialize(&msg.data()[..msg_size])
         };
 
         match entry {
             Ok(entry) => entries.push(entry),
             Err(err) => {
-                trace!("reconstruct_entry_from_blobs: {}", err);
-                return Err(err);
+                trace!("reconstruct_entry_from_blobs: {:?}", err);
+                return Err(Error::Serialize(err));
             }
         }
     }

src/packet.rs

@@ -139,11 +139,11 @@ impl Default for Blob {
     }
 }
 
-//#[derive(Debug)]
-//pub enum BlobError {
-//    /// the Blob's meta and data are not self-consistent
-//    BadState,
-//}
+#[derive(Debug)]
+pub enum BlobError {
+    /// the Blob's meta and data are not self-consistent
+    BadState,
+}
 
 pub struct Recycler<T> {
     gc: Arc<Mutex<Vec<Arc<RwLock<T>>>>>,
@@ -379,26 +379,13 @@ impl Blob {
     pub fn data_mut(&mut self) -> &mut [u8] {
         &mut self.data[BLOB_HEADER_SIZE..]
     }
-    pub fn get_size(&self) -> usize {
-        let size = self.get_data_size().unwrap() as usize;
-
+    pub fn get_size(&self) -> Result<usize> {
+        let size = self.get_data_size()? as usize;
         if self.meta.size == size {
-            size - BLOB_HEADER_SIZE
+            Ok(size - BLOB_HEADER_SIZE)
         } else {
-            0
+            Err(Error::BlobError(BlobError::BadState))
         }
-
-        // TODO: return a Result<usize> instead of
-        //        returning zero
-        //
-        //let size = self.get_data_size()? as usize;
-        //if self.meta.size == size {
-        //    Ok(size - BLOB_HEADER_SIZE)
-        //} else {
-        //    // these don't work...
-        //    Err("bad state")
-        //    // Err(BlobError::BadState)
-        //}
     }
     pub fn set_size(&mut self, size: usize) {
         let new_size = size + BLOB_HEADER_SIZE;

src/result.rs

@@ -5,6 +5,7 @@ use bincode;
 use crdt;
 #[cfg(feature = "erasure")]
 use erasure;
+use packet;
 use serde_json;
 use std;
 use std::any::Any;
@@ -22,6 +23,7 @@ pub enum Error {
     BankError(bank::BankError),
     CrdtError(crdt::CrdtError),
     WindowError(streamer::WindowError),
+    BlobError(packet::BlobError),
     #[cfg(feature = "erasure")]
     ErasureError(erasure::ErasureError),
     SendError,