change!: use separate error type for I/O hashing operations

Prepare for hashing becoming fallible.

Author: emilazy

gix-hash/src/hasher/io.rs

@@ -1,5 +1,13 @@
 use crate::{hasher, Hasher};
 
+/// The error type for I/O operations that compute hashes.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+}
+
 /// Compute the hash of `kind` for the bytes in the file at `path`, hashing only the first `num_bytes_from_start`
 /// while initializing and calling `progress`.
 ///
@@ -15,7 +23,7 @@ pub fn bytes_of_file(
     kind: crate::Kind,
     progress: &mut dyn gix_features::progress::Progress,
     should_interrupt: &std::sync::atomic::AtomicBool,
-) -> std::io::Result<crate::ObjectId> {
+) -> Result<crate::ObjectId, Error> {
     bytes(
         &mut std::fs::File::open(path)?,
         num_bytes_from_start,
@@ -32,7 +40,7 @@ pub fn bytes(
     kind: crate::Kind,
     progress: &mut dyn gix_features::progress::Progress,
     should_interrupt: &std::sync::atomic::AtomicBool,
-) -> std::io::Result<crate::ObjectId> {
+) -> Result<crate::ObjectId, Error> {
     bytes_with_hasher(read, num_bytes_from_start, hasher(kind), progress, should_interrupt)
 }
 
@@ -43,7 +51,7 @@ pub fn bytes_with_hasher(
     mut hasher: Hasher,
     progress: &mut dyn gix_features::progress::Progress,
     should_interrupt: &std::sync::atomic::AtomicBool,
-) -> std::io::Result<crate::ObjectId> {
+) -> Result<crate::ObjectId, Error> {
     let start = std::time::Instant::now();
     // init progress before the possibility for failure, as convenience in case people want to recover
     progress.init(
@@ -62,7 +70,7 @@ pub fn bytes_with_hasher(
         progress.inc_by(out.len());
         hasher.update(out);
         if should_interrupt.load(std::sync::atomic::Ordering::SeqCst) {
-            return Err(std::io::Error::new(std::io::ErrorKind::Other, "Interrupted"));
+            return Err(std::io::Error::new(std::io::ErrorKind::Other, "Interrupted").into());
         }
     }
 

gix-index/src/file/init.rs

@@ -2,6 +2,8 @@
 
 use std::path::{Path, PathBuf};
 
+use gix_hash::hasher;
+
 use crate::{decode, extension, File, State};
 
 mod error {
@@ -81,7 +83,10 @@ impl File {
                         object_hash,
                         &mut gix_features::progress::Discard,
                         &Default::default(),
-                    )?
+                    )
+                    .map_err(|err| match err {
+                        hasher::io::Error::Io(err) => Error::Io(err),
+                    })?
                     .verify(&expected)
                     .map_err(decode::Error::from)?;
                 }

gix-index/src/file/verify.rs

@@ -1,5 +1,7 @@
 use std::sync::atomic::AtomicBool;
 
+use gix_hash::hasher;
+
 use crate::File;
 
 mod error {
@@ -8,7 +10,7 @@ mod error {
     #[allow(missing_docs)]
     pub enum Error {
         #[error("Could not read index file to generate hash")]
-        Io(#[from] std::io::Error),
+        Io(#[from] gix_hash::hasher::io::Error),
         #[error("Index checksum mismatch")]
         Verify(#[from] gix_hash::verify::Error),
     }
@@ -20,7 +22,8 @@ impl File {
     pub fn verify_integrity(&self) -> Result<(), Error> {
         let _span = gix_features::trace::coarse!("gix_index::File::verify_integrity()");
         if let Some(checksum) = self.checksum {
-            let num_bytes_to_hash = self.path.metadata()?.len() - checksum.as_bytes().len() as u64;
+            let num_bytes_to_hash =
+                self.path.metadata().map_err(hasher::io::Error::from)?.len() - checksum.as_bytes().len() as u64;
             let should_interrupt = AtomicBool::new(false);
             gix_hash::bytes_of_file(
                 &self.path,

gix-index/src/file/write.rs

@@ -7,7 +7,7 @@ use crate::{write, File, Version};
 #[allow(missing_docs)]
 pub enum Error {
     #[error(transparent)]
-    Io(#[from] std::io::Error),
+    Io(#[from] hasher::io::Error),
     #[error("Could not acquire lock for index file")]
     AcquireLock(#[from] gix_lock::acquire::Error),
     #[error("Could not commit lock for index file")]
@@ -21,7 +21,7 @@ impl File {
         &self,
         mut out: impl std::io::Write,
         options: write::Options,
-    ) -> std::io::Result<(Version, gix_hash::ObjectId)> {
+    ) -> Result<(Version, gix_hash::ObjectId), hasher::io::Error> {
         let _span = gix_features::trace::detail!("gix_index::File::write_to()", skip_hash = options.skip_hash);
         let (version, hash) = if options.skip_hash {
             let out: &mut dyn std::io::Write = &mut out;
@@ -49,7 +49,7 @@ impl File {
         let (version, digest) = self.write_to(&mut lock, options)?;
         match lock.into_inner() {
             Ok(lock) => lock.commit()?,
-            Err(err) => return Err(err.into_error().into()),
+            Err(err) => return Err(Error::Io(err.into_error().into())),
         };
         self.state.version = version;
         self.checksum = Some(digest);

gix-index/src/write.rs

@@ -67,7 +67,7 @@ impl State {
             extensions,
             skip_hash: _,
         }: Options,
-    ) -> std::io::Result<Version> {
+    ) -> Result<Version, gix_hash::hasher::io::Error> {
         let _span = gix_features::trace::detail!("gix_index::State::write()");
         let version = self.detect_required_version();
 

gix-object/benches/edit_tree.rs

@@ -136,7 +136,10 @@ criterion_main!(benches);
 
 type TreeStore = Rc<RefCell<gix_hashtable::HashMap<ObjectId, Tree>>>;
 
-fn new_inmemory_writes() -> (TreeStore, impl FnMut(&Tree) -> Result<ObjectId, std::io::Error>) {
+fn new_inmemory_writes() -> (
+    TreeStore,
+    impl FnMut(&Tree) -> Result<ObjectId, gix_hash::hasher::io::Error>,
+) {
     let store = TreeStore::default();
     let write_tree = {
         let store = store.clone();

gix-object/src/lib.rs

@@ -424,7 +424,7 @@ pub fn compute_stream_hash(
     stream_len: u64,
     progress: &mut dyn gix_features::progress::Progress,
     should_interrupt: &std::sync::atomic::AtomicBool,
-) -> std::io::Result<gix_hash::ObjectId> {
+) -> Result<gix_hash::ObjectId, gix_hash::hasher::io::Error> {
     let hasher = object_hasher(hash_kind, object_kind, stream_len);
     gix_hash::bytes_with_hasher(stream, stream_len, hasher, progress, should_interrupt)
 }

gix-object/tests/object/tree/editor.rs

@@ -793,7 +793,7 @@ mod utils {
 
     pub(super) fn new_inmemory_writes() -> (
         TreeStore,
-        impl FnMut(&Tree) -> Result<ObjectId, std::io::Error>,
+        impl FnMut(&Tree) -> Result<ObjectId, gix_hash::hasher::io::Error>,
         impl Fn() -> usize,
     ) {
         let store = TreeStore::default();
@@ -805,7 +805,7 @@ mod utils {
             move |tree: &Tree| {
                 buf.clear();
                 tree.write_to(&mut buf)?;
-                let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Tree, &buf);
+                let id = gix_object::compute_hash(gix_hash::Kind::Sha1, gix_object::Kind::Tree, &buf)?;
                 store.borrow_mut().insert(id, tree.clone());
                 let old = num_writes.get();
                 num_writes.set(old + 1);

gix-odb/src/store_impls/loose/write.rs

@@ -14,7 +14,7 @@ use crate::store_impls::loose;
 pub enum Error {
     #[error("Could not {message} '{path}'")]
     Io {
-        source: io::Error,
+        source: hasher::io::Error,
         message: &'static str,
         path: PathBuf,
     },
@@ -31,12 +31,12 @@ impl gix_object::Write for Store {
     fn write(&self, object: &dyn WriteTo) -> Result<gix_hash::ObjectId, gix_object::write::Error> {
         let mut to = self.dest()?;
         to.write_all(&object.loose_header()).map_err(|err| Error::Io {
-            source: err,
+            source: err.into(),
             message: "write header to tempfile in",
             path: self.path.to_owned(),
         })?;
         object.write_to(&mut to).map_err(|err| Error::Io {
-            source: err,
+            source: err.into(),
             message: "stream all data into tempfile in",
             path: self.path.to_owned(),
         })?;
@@ -51,13 +51,13 @@ impl gix_object::Write for Store {
         let mut to = self.dest().map_err(Box::new)?;
         to.write_all(&gix_object::encode::loose_header(kind, from.len() as u64))
             .map_err(|err| Error::Io {
-                source: err,
+                source: err.into(),
                 message: "write header to tempfile in",
                 path: self.path.to_owned(),
             })?;
 
         to.write_all(from).map_err(|err| Error::Io {
-            source: err,
+            source: err.into(),
             message: "stream all data into tempfile in",
             path: self.path.to_owned(),
         })?;
@@ -77,14 +77,14 @@ impl gix_object::Write for Store {
         let mut to = self.dest().map_err(Box::new)?;
         to.write_all(&gix_object::encode::loose_header(kind, size))
             .map_err(|err| Error::Io {
-                source: err,
+                source: err.into(),
                 message: "write header to tempfile in",
                 path: self.path.to_owned(),
             })?;
 
         io::copy(&mut from, &mut to)
             .map_err(|err| Error::Io {
-                source: err,
+                source: err.into(),
                 message: "stream all data into tempfile in",
                 path: self.path.to_owned(),
             })
@@ -118,7 +118,7 @@ impl Store {
         }
         Ok(hasher::io::Write::new(
             deflate::Write::new(builder.tempfile_in(&self.path).map_err(|err| Error::Io {
-                source: err,
+                source: err.into(),
                 message: "create named temp file in",
                 path: self.path.to_owned(),
             })?),

gix-pack/src/data/input/bytes_to_entries.rs

@@ -1,7 +1,7 @@
 use std::{fs, io};
 
 use gix_features::zlib::Decompress;
-use gix_hash::{Hasher, ObjectId};
+use gix_hash::{hasher, Hasher, ObjectId};
 
 use crate::data::input;
 
@@ -52,7 +52,7 @@ where
         object_hash: gix_hash::Kind,
     ) -> Result<BytesToEntriesIter<BR>, input::Error> {
         let mut header_data = [0u8; 12];
-        read.read_exact(&mut header_data)?;
+        read.read_exact(&mut header_data).map_err(hasher::io::Error::from)?;
 
         let (version, num_objects) = crate::data::header::decode(&header_data)?;
         assert_eq!(
@@ -97,7 +97,7 @@ where
             }
             None => crate::data::Entry::from_read(&mut self.read, self.offset, self.hash_len),
         }
-        .map_err(input::Error::from)?;
+        .map_err(hasher::io::Error::from)?;
 
         // Decompress object to learn its compressed bytes
         let compressed_buf = self.compressed_buf.take().unwrap_or_else(|| Vec::with_capacity(4096));
@@ -114,7 +114,7 @@ where
             decompressor: &mut self.decompressor,
         };
 
-        let bytes_copied = io::copy(&mut decompressed_reader, &mut io::sink())?;
+        let bytes_copied = io::copy(&mut decompressed_reader, &mut io::sink()).map_err(hasher::io::Error::from)?;
         if bytes_copied != entry.decompressed_size {
             return Err(input::Error::IncompletePack {
                 actual: bytes_copied,
@@ -138,7 +138,10 @@ where
 
         let crc32 = if self.compressed.crc32() {
             let mut header_buf = [0u8; 12 + gix_hash::Kind::longest().len_in_bytes()];
-            let header_len = entry.header.write_to(bytes_copied, &mut header_buf.as_mut())?;
+            let header_len = entry
+                .header
+                .write_to(bytes_copied, &mut header_buf.as_mut())
+                .map_err(hasher::io::Error::from)?;
             let state = gix_features::hash::crc32_update(0, &header_buf[..header_len]);
             Some(gix_features::hash::crc32_update(state, &compressed))
         } else {
@@ -172,7 +175,7 @@ where
             let mut id = gix_hash::ObjectId::null(self.object_hash);
             if let Err(err) = self.read.read_exact(id.as_mut_slice()) {
                 if self.mode != input::Mode::Restore {
-                    return Err(err.into());
+                    return Err(input::Error::Io(err.into()));
                 }
             }
 
@@ -269,7 +272,8 @@ where
 impl crate::data::File {
     /// Returns an iterator over [`Entries`][crate::data::input::Entry], without making use of the memory mapping.
     pub fn streaming_iter(&self) -> Result<BytesToEntriesIter<impl io::BufRead>, input::Error> {
-        let reader = io::BufReader::with_capacity(4096 * 8, fs::File::open(&self.path)?);
+        let reader =
+            io::BufReader::with_capacity(4096 * 8, fs::File::open(&self.path).map_err(hasher::io::Error::from)?);
         BytesToEntriesIter::new_from_header(
             reader,
             input::Mode::Verify,

gix-pack/src/data/input/entries_to_bytes.rs

@@ -1,5 +1,7 @@
 use std::iter::Peekable;
 
+use gix_hash::hasher;
+
 use crate::data::input;
 
 /// An implementation of [`Iterator`] to write [encoded entries][input::Entry] to an inner implementation each time
@@ -64,7 +66,7 @@ where
         self.trailer
     }
 
-    fn next_inner(&mut self, entry: input::Entry) -> Result<input::Entry, input::Error> {
+    fn next_inner(&mut self, entry: input::Entry) -> Result<input::Entry, hasher::io::Error> {
         if self.num_entries == 0 {
             let header_bytes = crate::data::header::encode(self.data_version, 0);
             self.output.write_all(&header_bytes[..])?;
@@ -80,7 +82,7 @@ where
         Ok(entry)
     }
 
-    fn write_header_and_digest(&mut self, last_entry: Option<&mut input::Entry>) -> Result<(), input::Error> {
+    fn write_header_and_digest(&mut self, last_entry: Option<&mut input::Entry>) -> Result<(), hasher::io::Error> {
         let header_bytes = crate::data::header::encode(self.data_version, self.num_entries);
         let num_bytes_written = if last_entry.is_some() {
             self.output.stream_position()?
@@ -127,21 +129,24 @@ where
 
         match self.input.next() {
             Some(res) => Some(match res {
-                Ok(entry) => self.next_inner(entry).and_then(|mut entry| {
-                    if self.input.peek().is_none() {
-                        self.write_header_and_digest(Some(&mut entry)).map(|_| entry)
-                    } else {
-                        Ok(entry)
-                    }
-                }),
+                Ok(entry) => self
+                    .next_inner(entry)
+                    .and_then(|mut entry| {
+                        if self.input.peek().is_none() {
+                            self.write_header_and_digest(Some(&mut entry)).map(|_| entry)
+                        } else {
+                            Ok(entry)
+                        }
+                    })
+                    .map_err(input::Error::from),
                 Err(err) => {
                     self.is_done = true;
                     Err(err)
                 }
             }),
             None => match self.write_header_and_digest(None) {
                 Ok(_) => None,
-                Err(err) => Some(Err(err)),
+                Err(err) => Some(Err(err.into())),
             },
         }
     }

gix-pack/src/data/input/entry.rs

@@ -54,7 +54,7 @@ fn compress_data(obj: &gix_object::Data<'_>) -> Result<Vec<u8>, input::Error> {
     let mut out = gix_features::zlib::stream::deflate::Write::new(Vec::new());
     if let Err(err) = std::io::copy(&mut &*obj.data, &mut out) {
         match err.kind() {
-            std::io::ErrorKind::Other => return Err(input::Error::Io(err)),
+            std::io::ErrorKind::Other => return Err(input::Error::Io(err.into())),
             err => {
                 unreachable!("Should never see other errors than zlib, but got {:?}", err)
             }

gix-pack/src/data/input/types.rs

@@ -1,12 +1,12 @@
-use std::io;
+use gix_hash::hasher;
 
 /// Returned by [`BytesToEntriesIter::new_from_header()`][crate::data::input::BytesToEntriesIter::new_from_header()] and as part
 /// of `Item` of [`BytesToEntriesIter`][crate::data::input::BytesToEntriesIter].
 #[derive(thiserror::Error, Debug)]
 #[allow(missing_docs)]
 pub enum Error {
     #[error("An IO operation failed while streaming an entry")]
-    Io(#[from] io::Error),
+    Io(#[from] hasher::io::Error),
     #[error(transparent)]
     PackParse(#[from] crate::data::header::decode::Error),
     #[error("Failed to verify pack checksum in trailer")]