adapt to changes in `gix-object`

Sebastian Thiel committed 3 years ago

Commit ffcb1101 parent 9283a9d5 files · +33 −35Browse files

Unified · Split

5 files

gix-odb/src/find.rs +3 −3
gix-odb/src/sink.rs +4 −6
gix-odb/src/store_impls/loose/find.rs +17 −14
gix-odb/src/store_impls/loose/write.rs +8 −11
gix-odb/tests/odb/store/loose.rs +1 −1

@@ -104,11 +104,11 @@ mod header { · 103 unmodified lines
104	}	104	}
105	}	105	}
106		106
107	impl From<(usize, gix_object::Kind)> for Header {	107	impl From<(u64, gix_object::Kind)> for Header {
108	fn from((object_size, kind): (usize, gix_object::Kind)) -> Self {	108	fn from((object_size, kind): (u64, gix_object::Kind)) -> Self {
109	Header::Loose {	109	Header::Loose {
110	kind,	110	kind,
111	size: object_size as u64,	111	size: object_size,
112	}	112	}
113	}	113	}
114	}	114	}

gix-odb/src/sink.rs+4−6

 use std::{
     cell::RefCell,
-    convert::TryInto,
     io::{self, Write},
 };
     fn write_stream(
         &self,
         kind: gix_object::Kind,
-        size: u64,
+        mut size: u64,
         from: &mut dyn io::Read,
     ) -> Result<gix_hash::ObjectId, crate::write::Error> {
-        let mut size = size.try_into().expect("object size to fit into usize");
+        let mut buf = [0u8; u16::MAX as usize];
-        let mut buf = [0u8; 8096];
         let header = gix_object::encode::loose_header(kind, size);
         let possibly_compress = |buf: &[u8]| -> io::Result<()> {
         possibly_compress(&header).map_err(Box::new)?;
         while size != 0 {
-            let bytes = size.min(buf.len());
+            let bytes = (size as usize).min(buf.len());
             from.read_exact(&mut buf[..bytes]).map_err(Box::new)?;
             hasher.update(&buf[..bytes]);
             possibly_compress(&buf[..bytes]).map_err(Box::new)?;
-            size -= bytes;
+            size -= bytes as u64;
         }
         if let Some(compressor) = self.compressor.as_ref() {
             let mut c = compressor.borrow_mut();

gix-odb/src/store_impls/loose/find.rs+17−14

         path: PathBuf,
     },
     #[error("file at '{path}' showed invalid size of inflated data, expected {expected}, got {actual}")]
-    SizeMismatch {
+    SizeMismatch { actual: u64, expected: u64, path: PathBuf },
-        actual: usize,
-        expected: usize,
-        path: PathBuf,
-    },
     #[error(transparent)]
     Decode(#[from] gix_object::decode::LooseHeaderDecodeError),
+    #[error("Cannot store {size} in memory as it's not representable")]
+    OutOfMemory { size: u64 },
     #[error("Could not {action} data at '{path}'")]
     Io {
         source: std::io::Error,
     /// Return only the decompressed size of the object and its kind without fully reading it into memory as tuple of `(size, kind)`.
     /// Returns `None` if `id` does not exist in the database.
-    pub fn try_header(&self, id: &gix_hash::oid) -> Result<Option<(usize, gix_object::Kind)>, Error> {
+    pub fn try_header(&self, id: &gix_hash::oid) -> Result<Option<(u64, gix_object::Kind)>, Error> {
         const BUF_SIZE: usize = 256;
         let mut buf = [0_u8; BUF_SIZE];
         let path = hash_path(id, self.path.clone());
             let decompressed_body_bytes_sans_header =
                 decompressed_start + header_size..decompressed_start + consumed_out;
-            if consumed_out != size + header_size {
+            if consumed_out as u64 != size + header_size as u64 {
                 return Err(Error::SizeMismatch {
-                    expected: size + header_size,
+                    expected: size + header_size as u64,
-                    actual: consumed_out,
+                    actual: consumed_out as u64,
                     path,
                 });
             }
             buf.copy_within(decompressed_body_bytes_sans_header, 0);
         } else {
-            buf.resize(bytes_read + size + header_size, 0);
+            let new_len = bytes_read as u64 + size + header_size as u64;
+            buf.resize(new_len.try_into().map_err(|_| Error::OutOfMemory { size: new_len })?, 0);
             {
                 let (input, output) = buf.split_at_mut(bytes_read);
                 let num_decompressed_bytes = zlib::stream::inflate::read(
                     action: "deflate",
                     path: path.to_owned(),
                 })?;
-                if num_decompressed_bytes + consumed_out != size + header_size {
+                if num_decompressed_bytes as u64 + consumed_out as u64 != size + header_size as u64 {
                     return Err(Error::SizeMismatch {
-                        expected: size + header_size,
+                        expected: size + header_size as u64,
-                        actual: num_decompressed_bytes + consumed_out,
+                        actual: num_decompressed_bytes as u64 + consumed_out as u64,
                         path,
                     });
                 }
             };
             buf.copy_within(decompressed_start + header_size.., 0);
         }
-        buf.resize(size, 0);
+        buf.resize(
+            size.try_into()
+                .expect("BUG: here the size is already confirmed to fit into memory"),
+            0,
+        );
         Ok(gix_object::Data { kind, data: buf })
     }
 }

gix-odb/src/store_impls/loose/write.rs+8−11

-use std::{convert::TryInto, fs, io, io::Write, path::PathBuf};
+use std::{fs, io, io::Write, path::PathBuf};
 use gix_features::{hash, zlib::stream::deflate};
 use gix_object::WriteTo;
     /// This will cost at least 4 IO operations.
     fn write_buf(&self, kind: gix_object::Kind, from: &[u8]) -> Result<gix_hash::ObjectId, crate::write::Error> {
         let mut to = self.dest().map_err(Box::new)?;
-        to.write_all(&gix_object::encode::loose_header(kind, from.len()))
+        to.write_all(&gix_object::encode::loose_header(kind, from.len() as u64))
             .map_err(|err| Error::Io {
                 source: err,
                 message: "write header to tempfile in",
         mut from: &mut dyn io::Read,
     ) -> Result<gix_hash::ObjectId, crate::write::Error> {
         let mut to = self.dest().map_err(Box::new)?;
-        to.write_all(&gix_object::encode::loose_header(
+        to.write_all(&gix_object::encode::loose_header(kind, size))
-            kind,
+            .map_err(|err| Error::Io {
-            size.try_into().expect("object size to fit into usize"),
+                source: err,
-        ))
+                message: "write header to tempfile in",
-        .map_err(|err| Error::Io {
+                path: self.path.to_owned(),
-            source: err,
+            })?;
-            message: "write header to tempfile in",
-            path: self.path.to_owned(),
-        })?;
         io::copy(&mut from, &mut to)
             .map_err(|err| Error::Io {

gix-odb/tests/odb/store/loose.rs+1−1

@@ -420,7 +420,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB · 419 unmodified lines
420	let id = id?;	420	let id = id?;
421	let expected = db.try_find(&id, &mut buf)?.expect("exists");	421	let expected = db.try_find(&id, &mut buf)?.expect("exists");
422	let (size, kind) = db.try_header(&id)?.expect("header exists");	422	let (size, kind) = db.try_header(&id)?.expect("header exists");
423	assert_eq!(size, expected.data.len());	423	assert_eq!(size, expected.data.len() as u64);
424	assert_eq!(kind, expected.kind);	424	assert_eq!(kind, expected.kind);
425	}	425	}
426	Ok(())	426	Ok(())