fix bitrot

ecstore/src/erasure_coding/bitrot.rs

@@ -1,7 +1,9 @@
 use bytes::Bytes;
 use pin_project_lite::pin_project;
-use rustfs_utils::{HashAlgorithm, read_full, write_all};
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite};
+use rustfs_utils::HashAlgorithm;
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+use tracing::error;
+use uuid::Uuid;
 
 pin_project! {
     /// BitrotReader reads (hash+data) blocks from an async reader and verifies hash integrity.
@@ -12,10 +14,11 @@ pin_project! {
         shard_size: usize,
         buf: Vec<u8>,
         hash_buf: Vec<u8>,
-        hash_read: usize,
-        data_buf: Vec<u8>,
-        data_read: usize,
-        hash_checked: bool,
+        // hash_read: usize,
+        // data_buf: Vec<u8>,
+        // data_read: usize,
+        // hash_checked: bool,
+        id: Uuid,
     }
 }
 
@@ -32,10 +35,11 @@ where
             shard_size,
             buf: Vec::new(),
             hash_buf: vec![0u8; hash_size],
-            hash_read: 0,
-            data_buf: Vec::new(),
-            data_read: 0,
-            hash_checked: false,
+            // hash_read: 0,
+            // data_buf: Vec::new(),
+            // data_read: 0,
+            // hash_checked: false,
+            id: Uuid::new_v4(),
         }
     }
 
@@ -51,30 +55,31 @@ where
 
         let hash_size = self.hash_algo.size();
         // Read hash
-        let mut hash_buf = vec![0u8; hash_size];
+
         if hash_size > 0 {
-            self.inner.read_exact(&mut hash_buf).await?;
+            self.inner.read_exact(&mut self.hash_buf).await.map_err(|e| {
+                error!("bitrot reader read hash error: {}", e);
+                e
+            })?;
         }
 
-        let data_len = read_full(&mut self.inner, out).await?;
-
-        // // Read data
-        // let mut data_len = 0;
-        // while data_len < out.len() {
-        //     let n = self.inner.read(&mut out[data_len..]).await?;
-        //     if n == 0 {
-        //         break;
-        //     }
-        //     data_len += n;
-        //     // Only read up to one shard_size block
-        //     if data_len >= self.shard_size {
-        //         break;
-        //     }
-        // }
+        // Read data
+        let mut data_len = 0;
+        while data_len < out.len() {
+            let n = self.inner.read(&mut out[data_len..]).await.map_err(|e| {
+                error!("bitrot reader read data error: {}", e);
+                e
+            })?;
+            if n == 0 {
+                break;
+            }
+            data_len += n;
+        }
 
         if hash_size > 0 {
             let actual_hash = self.hash_algo.hash_encode(&out[..data_len]);
-            if actual_hash.as_ref() != hash_buf.as_slice() {
+            if actual_hash.as_ref() != self.hash_buf.as_slice() {
+                error!("bitrot reader hash mismatch, id={} data_len={}, out_len={}", self.id, data_len, out.len());
                 return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot hash mismatch"));
             }
         }
@@ -145,22 +150,20 @@ where
 
         self.buf.extend_from_slice(buf);
 
-        // Write hash+data in one call
-        let mut n = write_all(&mut self.inner, &self.buf).await?;
+        self.inner.write_all(&self.buf).await?;
 
-        if n < hash_algo.size() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::WriteZero,
-                "short write: not enough bytes written",
-            ));
-        }
+        self.inner.flush().await?;
 
-        n -= hash_algo.size();
+        let n = self.buf.len();
 
         self.buf.clear();
 
         Ok(n)
     }
+
+    pub async fn shutdown(&mut self) -> std::io::Result<()> {
+        self.inner.shutdown().await
+    }
 }
 
 pub fn bitrot_shard_file_size(size: usize, shard_size: usize, algo: HashAlgorithm) -> usize {
@@ -330,6 +333,10 @@ impl BitrotWriterWrapper {
         self.bitrot_writer.write(buf).await
     }
 
+    pub async fn shutdown(&mut self) -> std::io::Result<()> {
+        self.bitrot_writer.shutdown().await
+    }
+
     /// Extract the inline buffer data, consuming the wrapper
     pub fn into_inline_data(self) -> Option<Vec<u8>> {
         match self.writer_type {