[ci] Fix CI issues for multi-hash support

Signed-off-by: jackieismpc <[email protected]>

Author: jackieismpc

BUCK

@@ -73,5 +73,6 @@ rust_library(
         "//third-party/rust/crates/tracing/0.1.41:tracing",
         "//third-party/rust/crates/uuid/1.18.1:uuid",
         "//third-party/rust/crates/zstd-sys/2.0.16+zstd.1.5.7:zstd-sys",
+        "//third-party/rust/crates/sha2/0.10.9:sha2",
     ],
 )

src/internal/index.rs

@@ -9,12 +9,11 @@ use std::path::{Path, PathBuf};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-use sha1::{Digest, Sha1};
 
 use crate::errors::GitError;
 use crate::hash::{ObjectHash, get_hash_kind};
 use crate::internal::pack::wrapper::Wrapper;
-use crate::utils::{self, Hashalgorithm};
+use crate::utils::{self, HashAlgorithm};
 
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub struct Time {
@@ -281,15 +280,16 @@ impl Index {
                 .insert((entry.name.clone(), entry.flags.stage), entry);
 
             // 1-8 nul bytes as necessary to pad the entry to a multiple of eight bytes
-            // while keeping the name NUL-terminated. // so at least 1 byte nul
+            // while keeping the name NUL-terminated.
             let hash_len = get_hash_kind().size();
-            let padding = (8 - ((hash_len + 2 + name_len) % 8)) % 8; // 2 for flags
+            let entry_len = hash_len + 2 + name_len;
+            let padding = 1 + ((8 - ((entry_len + 1) % 8)) % 8); // at least 1 byte nul
             utils::read_bytes(file, padding)?;
         }
 
         // Extensions
         while file.bytes_read() + get_hash_kind().size() < total_size as usize {
-            // The remaining 20 bytes must be checksum
+            // The remaining bytes must be the pack checksum (size = get_hash_kind().size())
             let sign = utils::read_bytes(file, 4)?;
             println!(
                 "{:?}",
@@ -321,7 +321,7 @@ impl Index {
 
     pub fn to_file(&self, path: impl AsRef<Path>) -> Result<(), GitError> {
         let mut file = File::create(path)?;
-        let mut hash = Sha1::new();
+        let mut hash = HashAlgorithm::new();
 
         let mut header = Vec::new();
         header.write_all(b"DIRC")?;
@@ -342,21 +342,23 @@ impl Index {
             entry_bytes.write_u32::<BigEndian>(entry.uid)?;
             entry_bytes.write_u32::<BigEndian>(entry.gid)?;
             entry_bytes.write_u32::<BigEndian>(entry.size)?;
-            entry_bytes.write_all(&entry.hash.as_ref())?;
+            entry_bytes.write_all(entry.hash.as_ref())?;
             entry_bytes.write_u16::<BigEndian>((&entry.flags).try_into().unwrap())?;
             entry_bytes.write_all(entry.name.as_bytes())?;
-            let padding = 8 - ((22 + entry.name.len()) % 8);
+            let hash_len = get_hash_kind().size();
+            let entry_len = hash_len + 2 + entry.name.len();
+            let padding = 1 + ((8 - ((entry_len + 1) % 8)) % 8); // at least 1 byte nul
             entry_bytes.write_all(&vec![0; padding])?;
-
             file.write_all(&entry_bytes)?;
             hash.update(&entry_bytes);
         }
 
         // Extensions
 
         // check sum
-        let file_hash: [u8; 20] = hash.finalize().into();
-        file.write_all(&file_hash)?;
+        let file_hash =
+            ObjectHash::from_bytes(&hash.finalize()).map_err(GitError::InvalidIndexFile)?;
+        file.write_all(file_hash.as_ref())?;
         Ok(())
     }
 
@@ -384,7 +386,7 @@ impl Index {
 
             // re-calculate SHA1/SHA256
             let mut file = File::open(&abs_path)?;
-            let mut hasher = Hashalgorithm::new();
+            let mut hasher = HashAlgorithm::new();
             io::copy(&mut file, &mut hasher)?;
             let new_hash = ObjectHash::from_bytes(&hasher.finalize()).unwrap();
 

src/internal/object/commit.rs

@@ -360,7 +360,7 @@ signed sha256 commit for test"#;
         assert_eq!(commit.author.name, "jackieismpc");
         assert_eq!(commit.author.email, "[email protected]");
         assert_eq!(commit.committer.name, "jackieismpc");
-        // check message content（must contains gpgsig-sha256 and content）
+        // // check message content (must contain gpgsig-sha256 and content)
         assert!(commit.message.contains("-----BEGIN PGP SIGNATURE-----"));
         assert!(commit.message.contains("-----END PGP SIGNATURE-----"));
         assert!(commit.message.contains("signed sha256 commit for test"));

src/internal/object/tree.rs

@@ -413,7 +413,7 @@ mod tests {
 
         let bytes = tree_item.to_data();
 
-        // 一个小 helper：把十六进制字符串转成字节序列
+        // a small helper: convert hex string to byte sequence
         fn hex_to_bytes(s: &str) -> Vec<u8> {
             assert!(s.len() % 2 == 0);
             let mut out = Vec::with_capacity(s.len() / 2);
@@ -424,7 +424,7 @@ mod tests {
             out
         }
 
-        // 期望的编码：`"100644 hello-world\0" + <32字节的blob哈希>`
+        // expected encoding: `"100644 hello-world\0" + <32-byte blob hash>`
         let mut expected = b"100644 hello-world\0".to_vec();
         expected.extend_from_slice(&hex_to_bytes(
             "2cf8d83d9ee29543b34a87727421fdecb7e3f3a183d337639025de576db9ebb4",

src/internal/pack/cache.rs

@@ -89,7 +89,7 @@ impl Caches {
 
     /// generate the temp file path, hex string of the hash
     fn generate_temp_path(&self, tmp_path: &Path, hash: ObjectHash) -> PathBuf {
-        // This is enough for the original path, 2 chars directory, 40/64 chars hash, and extra slashes
+        // Reserve capacity for base path, 2-char subdir, hex hash string, and separators
         let mut path =
             PathBuf::with_capacity(self.tmp_path.capacity() + hash.to_string().len() + 5);
         path.push(tmp_path);

src/internal/pack/cache_object.rs

@@ -478,11 +478,11 @@ mod test {
             );
             assert!(r.is_err());
             if let Err(lru_mem::TryInsertError::WouldEjectLru { .. }) = r {
-                // 匹配到指定错误，不需要额外操作
+                // match the specified error, no extra action needed
             } else {
                 panic!("Expected WouldEjectLru error");
             }
-            // 使用不同的键插入b，这样a会被驱逐
+            // insert b with a different key, so a will be ejected
             let r = cache.insert(
                 hash_b.to_string(),
                 ArcWrapper::new(Arc::new(b.clone()), Arc::new(AtomicBool::new(true)), None),

src/internal/pack/decode.rs

@@ -309,8 +309,8 @@ impl Pack {
                 })
             }
             ObjectType::HashDelta => {
-                // Read 20/32 bytes to get the reference object SHA1/SHA256 hash
-                let ref_sha1 = ObjectHash::from_stream(pack).unwrap();
+                // Read hash bytes to get the reference object hash(size depends on hash kind,e.g.,20 for SHA1,32 for SHA256)
+                let ref_sha = ObjectHash::from_stream(pack).unwrap();
                 // Offset is incremented by 20/32 bytes
                 *offset += get_hash_kind().size();
 
@@ -321,7 +321,7 @@ impl Pack {
                 let (_, final_size) = utils::read_delta_object_size(&mut reader)?;
 
                 Ok(CacheObject {
-                    info: CacheObjectInfo::HashDelta(ref_sha1, final_size),
+                    info: CacheObjectInfo::HashDelta(ref_sha, final_size),
                     offset: init_offset,
                     data_decompressed: data,
                     mem_recorder: None,
@@ -881,7 +881,7 @@ mod tests {
         let mut buffered = BufReader::new(f);
         let mut p = Pack::new(
             Some(20),
-            Some(1024 * 1024 * 1024 * 2),
+            Some(1024 * 1024 * 1024 * 1), //try to avoid dead lock on CI servers with low memory
             Some(tmp.clone()),
             true,
         );
@@ -933,7 +933,7 @@ mod tests {
         let stream = ReaderStream::new(f).map_err(axum::Error::new);
         let p = Pack::new(
             Some(20),
-            Some(1024 * 1024 * 1024 * 4),
+            Some(1024 * 1024 * 1024 * 1),
             Some(tmp.clone()),
             true,
         );
@@ -997,7 +997,7 @@ mod tests {
         let buffered = BufReader::new(f);
         let p = Pack::new(
             Some(20),
-            Some(1024 * 1024 * 1024 * 2),
+            Some(1024 * 1024 * 1024 * 1),
             Some(tmp.clone()),
             true,
         );

src/internal/pack/encode.rs

@@ -8,7 +8,7 @@ use crate::internal::object::types::ObjectType;
 use crate::time_it;
 use crate::zstdelta;
 use crate::{
-    errors::GitError, hash::ObjectHash, internal::pack::entry::Entry, utils::Hashalgorithm,
+    errors::GitError, hash::ObjectHash, internal::pack::entry::Entry, utils::HashAlgorithm,
 };
 use ahash::AHasher;
 use flate2::write::ZlibEncoder;
@@ -32,7 +32,7 @@ pub struct PackEncoder {
     // window: VecDeque<(Entry, usize)>, // entry and offset
     sender: Option<mpsc::Sender<Vec<u8>>>,
     inner_offset: usize,       // offset of current entry
-    inner_hash: Hashalgorithm, // introduce different hash algorithm
+    inner_hash: HashAlgorithm, // introduce different hash algorithm
     final_hash: Option<ObjectHash>,
     start_encoding: bool,
 }
@@ -186,8 +186,8 @@ impl PackEncoder {
             process_index: 0,
             // window: VecDeque::with_capacity(window_size),
             sender: Some(sender),
-            inner_offset: 12,                 // 12 bytes header
-            inner_hash: Hashalgorithm::new(), // introduce different hash algorithm
+            inner_offset: 12, // start  after 12 bytes pack header(signature + version + object count).
+            inner_hash: HashAlgorithm::new(), // introduce different hash algorithm
             final_hash: None,
             start_encoding: false,
         }

src/internal/pack/wrapper.rs

@@ -3,7 +3,7 @@ use std::io::{self, BufRead, Read};
 use sha1::{Digest, Sha1};
 
 use crate::hash::{HashKind, ObjectHash, get_hash_kind};
-
+use crate::utils::HashAlgorithm;
 /// [`Wrapper`] is a wrapper around a reader that also computes the SHA1/ SHA256 hash of the data read.
 ///
 /// It is designed to work with any reader that implements `BufRead`.
@@ -13,15 +13,9 @@ use crate::hash::{HashKind, ObjectHash, get_hash_kind};
 /// * `hash`: The  hash state.
 /// * `count_hash`: A flag to indicate whether to compute the hash while reading.
 ///
-/// we abstract the hasher to support both SHA1 and SHA256 Now.
-#[derive(Clone)]
-enum Hasher {
-    Sha1(Sha1),
-    Sha256(sha2::Sha256),
-}
 pub struct Wrapper<R> {
     inner: R,
-    hash: Hasher,
+    hash: HashAlgorithm,
     bytes_read: usize,
 }
 
@@ -38,8 +32,8 @@ where
         Self {
             inner,
             hash: match get_hash_kind() {
-                HashKind::Sha1 => Hasher::Sha1(Sha1::new()),
-                HashKind::Sha256 => Hasher::Sha256(sha2::Sha256::new()),
+                HashKind::Sha1 => HashAlgorithm::Sha1(Sha1::new()),
+                HashKind::Sha256 => HashAlgorithm::Sha256(sha2::Sha256::new()),
             }, // Initialize a new SHA1/ SHA256 hasher
             bytes_read: 0,
         }
@@ -54,11 +48,11 @@ where
     /// This is a clone of the internal hash state finalized into a SHA1/ SHA256 hash.
     pub fn final_hash(&self) -> ObjectHash {
         match &self.hash.clone() {
-            Hasher::Sha1(hasher) => {
+            HashAlgorithm::Sha1(hasher) => {
                 let re: [u8; 20] = hasher.clone().finalize().into(); // Clone, finalize, and convert the hash into bytes
                 ObjectHash::from_bytes(&re).unwrap()
             }
-            Hasher::Sha256(hasher) => {
+            HashAlgorithm::Sha256(hasher) => {
                 let re: [u8; 32] = hasher.clone().finalize().into(); // Clone, finalize, and convert the hash into bytes
                 ObjectHash::from_bytes(&re).unwrap()
             }
@@ -82,8 +76,8 @@ where
     fn consume(&mut self, amt: usize) {
         let buffer = self.inner.fill_buf().expect("Failed to fill buffer");
         match &mut self.hash {
-            Hasher::Sha1(hasher) => hasher.update(&buffer[..amt]), // Update SHA1 hash with the data being consumed
-            Hasher::Sha256(hasher) => hasher.update(&buffer[..amt]), // Update SHA256 hash with the data being consumed
+            HashAlgorithm::Sha1(hasher) => hasher.update(&buffer[..amt]), // Update SHA1 hash with the data being consumed
+            HashAlgorithm::Sha256(hasher) => hasher.update(&buffer[..amt]), // Update SHA256 hash with the data being consumed
         }
         self.inner.consume(amt); // Consume the data from the inner reader
         self.bytes_read += amt;
@@ -105,8 +99,8 @@ where
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let o = self.inner.read(buf)?; // Read data into the buffer
         match &mut self.hash {
-            Hasher::Sha1(hasher) => hasher.update(&buf[..o]), // Update SHA1 hash with the data being read
-            Hasher::Sha256(hasher) => hasher.update(&buf[..o]), // Update SHA256 hash with the data being read
+            HashAlgorithm::Sha1(hasher) => hasher.update(&buf[..o]), // Update SHA1 hash with the data being read
+            HashAlgorithm::Sha256(hasher) => hasher.update(&buf[..o]), // Update SHA256 hash with the data being read
         }
         self.bytes_read += o;
         Ok(o) // Return the number of bytes read

src/protocol/smart.rs

@@ -298,7 +298,7 @@ where
         for command in &mut self.command_list {
             if command.ref_type == RefTypeEnum::Tag {
                 // Just update if refs type is tag
-                // Convert ze to None for old hash
+                // Convert zero_id to None for old hash
                 let old_hash = if command.old_hash == self.zero_id {
                     None
                 } else {