add rio/filemeta

crates/rio/src/bitrot.rs

@@ -0,0 +1,325 @@
+use crate::{Reader, Writer};
+use pin_project_lite::pin_project;
+use rustfs_utils::{read_full, write_all, HashAlgorithm};
+use tokio::io::{AsyncRead, AsyncReadExt};
+
+pin_project! {
+    /// BitrotReader reads (hash+data) blocks from an async reader and verifies hash integrity.
+    pub struct BitrotReader {
+        #[pin]
+        inner: Box<dyn Reader>,
+        hash_algo: HashAlgorithm,
+        shard_size: usize,
+        buf: Vec<u8>,
+        hash_buf: Vec<u8>,
+        hash_read: usize,
+        data_buf: Vec<u8>,
+        data_read: usize,
+        hash_checked: bool,
+    }
+}
+
+impl BitrotReader {
+    /// Get a reference to the underlying reader.
+    pub fn get_ref(&self) -> &dyn Reader {
+        &*self.inner
+    }
+
+    /// Create a new BitrotReader.
+    pub fn new(inner: Box<dyn Reader>, shard_size: usize, algo: HashAlgorithm) -> Self {
+        let hash_size = algo.size();
+        Self {
+            inner,
+            hash_algo: algo,
+            shard_size,
+            buf: Vec::new(),
+            hash_buf: vec![0u8; hash_size],
+            hash_read: 0,
+            data_buf: Vec::new(),
+            data_read: 0,
+            hash_checked: false,
+        }
+    }
+
+    /// Read a single (hash+data) block, verify hash, and return the number of bytes read into `out`.
+    /// Returns an error if hash verification fails or data exceeds shard_size.
+    pub async fn read(&mut self, out: &mut [u8]) -> std::io::Result<usize> {
+        if out.len() > self.shard_size {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("data size {} exceeds shard size {}", out.len(), self.shard_size),
+            ));
+        }
+
+        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?;
+        }
+
+        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;
+        //     }
+        // }
+
+        if hash_size > 0 {
+            let actual_hash = self.hash_algo.hash_encode(&out[..data_len]);
+            if actual_hash != hash_buf {
+                return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot hash mismatch"));
+            }
+        }
+        Ok(data_len)
+    }
+}
+
+pin_project! {
+    /// BitrotWriter writes (hash+data) blocks to an async writer.
+    pub struct BitrotWriter {
+        #[pin]
+        inner: Writer,
+        hash_algo: HashAlgorithm,
+        shard_size: usize,
+        buf: Vec<u8>,
+        finished: bool,
+    }
+}
+
+impl BitrotWriter {
+    /// Create a new BitrotWriter.
+    pub fn new(inner: Writer, shard_size: usize, algo: HashAlgorithm) -> Self {
+        let hash_algo = algo;
+        Self {
+            inner,
+            hash_algo,
+            shard_size,
+            buf: Vec::new(),
+            finished: false,
+        }
+    }
+
+    pub fn into_inner(self) -> Writer {
+        self.inner
+    }
+
+    /// Write a (hash+data) block. Returns the number of data bytes written.
+    /// Returns an error if called after a short write or if data exceeds shard_size.
+    pub async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
+        if self.finished {
+            return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, "bitrot writer already finished"));
+        }
+
+        if buf.len() > self.shard_size {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("data size {} exceeds shard size {}", buf.len(), self.shard_size),
+            ));
+        }
+
+        if buf.len() < self.shard_size {
+            self.finished = true;
+        }
+
+        let hash_algo = &self.hash_algo;
+
+        if hash_algo.size() > 0 {
+            let hash = hash_algo.hash_encode(buf);
+            self.buf.extend_from_slice(&hash);
+        }
+
+        self.buf.extend_from_slice(buf);
+
+        // Write hash+data in one call
+        let mut n = write_all(&mut self.inner, &self.buf).await?;
+
+        if n < hash_algo.size() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::WriteZero,
+                "short write: not enough bytes written",
+            ));
+        }
+
+        n -= hash_algo.size();
+
+        self.buf.clear();
+
+        Ok(n)
+    }
+}
+
+pub fn bitrot_shard_file_size(size: usize, shard_size: usize, algo: HashAlgorithm) -> usize {
+    if algo != HashAlgorithm::HighwayHash256S {
+        return size;
+    }
+    size.div_ceil(shard_size) * algo.size() + size
+}
+
+pub async fn bitrot_verify<R: AsyncRead + Unpin + Send>(
+    mut r: R,
+    want_size: usize,
+    part_size: usize,
+    algo: HashAlgorithm,
+    _want: Vec<u8>,
+    mut shard_size: usize,
+) -> std::io::Result<()> {
+    let mut hash_buf = vec![0; algo.size()];
+    let mut left = want_size;
+
+    if left != bitrot_shard_file_size(part_size, shard_size, algo.clone()) {
+        return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot shard file size mismatch"));
+    }
+
+    while left > 0 {
+        let n = r.read_exact(&mut hash_buf).await?;
+        left -= n;
+
+        if left < shard_size {
+            shard_size = left;
+        }
+
+        let mut buf = vec![0; shard_size];
+        let read = r.read_exact(&mut buf).await?;
+
+        let actual_hash = algo.hash_encode(&buf);
+        if actual_hash != hash_buf[0..n] {
+            return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bitrot hash mismatch"));
+        }
+
+        left -= read;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::{BitrotReader, BitrotWriter, Writer};
+    use rustfs_utils::HashAlgorithm;
+    use std::io::Cursor;
+
+    #[tokio::test]
+    async fn test_bitrot_read_write_ok() {
+        let data = b"hello world! this is a test shard.";
+        let data_size = data.len();
+        let shard_size = 8;
+
+        let buf = Vec::new();
+        let writer = Cursor::new(buf);
+        let mut bitrot_writer = BitrotWriter::new(Writer::from_cursor(writer), shard_size, HashAlgorithm::HighwayHash256);
+
+        let mut n = 0;
+        for chunk in data.chunks(shard_size) {
+            n += bitrot_writer.write(chunk).await.unwrap();
+        }
+        assert_eq!(n, data.len());
+
+        // 读
+        let reader = Cursor::new(bitrot_writer.into_inner().into_cursor_inner().unwrap());
+        let reader = Box::new(reader);
+        let mut bitrot_reader = BitrotReader::new(reader, shard_size, HashAlgorithm::HighwayHash256);
+        let mut out = Vec::new();
+        let mut n = 0;
+        while n < data_size {
+            let mut buf = vec![0u8; shard_size];
+            let m = bitrot_reader.read(&mut buf).await.unwrap();
+            assert_eq!(&buf[..m], &data[n..n + m]);
+
+            out.extend_from_slice(&buf[..m]);
+            n += m;
+        }
+
+        assert_eq!(n, data_size);
+        assert_eq!(data, &out[..]);
+    }
+
+    #[tokio::test]
+    async fn test_bitrot_read_hash_mismatch() {
+        let data = b"test data for bitrot";
+        let data_size = data.len();
+        let shard_size = 8;
+        let buf = Vec::new();
+        let writer = Cursor::new(buf);
+        let mut bitrot_writer = BitrotWriter::new(Writer::from_cursor(writer), shard_size, HashAlgorithm::HighwayHash256);
+        for chunk in data.chunks(shard_size) {
+            let _ = bitrot_writer.write(chunk).await.unwrap();
+        }
+        let mut written = bitrot_writer.into_inner().into_cursor_inner().unwrap();
+        // change the last byte to make hash mismatch
+        let pos = written.len() - 1;
+        written[pos] ^= 0xFF;
+        let reader = Cursor::new(written);
+        let reader = Box::new(reader);
+        let mut bitrot_reader = BitrotReader::new(reader, shard_size, HashAlgorithm::HighwayHash256);
+
+        let count = data_size.div_ceil(shard_size);
+
+        let mut idx = 0;
+        let mut n = 0;
+        while n < data_size {
+            let mut buf = vec![0u8; shard_size];
+            let res = bitrot_reader.read(&mut buf).await;
+
+            if idx == count - 1 {
+                // 最后一个块，应该返回错误
+                assert!(res.is_err());
+                assert_eq!(res.unwrap_err().kind(), std::io::ErrorKind::InvalidData);
+                break;
+            }
+
+            let m = res.unwrap();
+
+            assert_eq!(&buf[..m], &data[n..n + m]);
+
+            n += m;
+            idx += 1;
+        }
+    }
+
+    #[tokio::test]
+    async fn test_bitrot_read_write_none_hash() {
+        let data = b"bitrot none hash test data!";
+        let data_size = data.len();
+        let shard_size = 8;
+
+        let buf = Vec::new();
+        let writer = Cursor::new(buf);
+        let mut bitrot_writer = BitrotWriter::new(Writer::from_cursor(writer), shard_size, HashAlgorithm::None);
+
+        let mut n = 0;
+        for chunk in data.chunks(shard_size) {
+            n += bitrot_writer.write(chunk).await.unwrap();
+        }
+        assert_eq!(n, data.len());
+
+        let reader = Cursor::new(bitrot_writer.into_inner().into_cursor_inner().unwrap());
+        let reader = Box::new(reader);
+        let mut bitrot_reader = BitrotReader::new(reader, shard_size, HashAlgorithm::None);
+        let mut out = Vec::new();
+        let mut n = 0;
+        while n < data_size {
+            let mut buf = vec![0u8; shard_size];
+            let m = bitrot_reader.read(&mut buf).await.unwrap();
+            assert_eq!(&buf[..m], &data[n..n + m]);
+            out.extend_from_slice(&buf[..m]);
+            n += m;
+        }
+        assert_eq!(n, data_size);
+        assert_eq!(data, &out[..]);
+    }
+}

crates/rio/src/compress.rs

@@ -0,0 +1,270 @@
+use http::HeaderMap;
+use std::io::Write;
+use tokio::io;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
+pub enum CompressionAlgorithm {
+    Gzip,
+    #[default]
+    Deflate,
+    Zstd,
+    Lz4,
+    Brotli,
+    Snappy,
+}
+
+impl CompressionAlgorithm {
+    pub fn as_str(&self) -> &str {
+        match self {
+            CompressionAlgorithm::Gzip => "gzip",
+            CompressionAlgorithm::Deflate => "deflate",
+            CompressionAlgorithm::Zstd => "zstd",
+            CompressionAlgorithm::Lz4 => "lz4",
+            CompressionAlgorithm::Brotli => "brotli",
+            CompressionAlgorithm::Snappy => "snappy",
+        }
+    }
+}
+
+impl std::fmt::Display for CompressionAlgorithm {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+impl std::str::FromStr for CompressionAlgorithm {
+    type Err = std::io::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "gzip" => Ok(CompressionAlgorithm::Gzip),
+            "deflate" => Ok(CompressionAlgorithm::Deflate),
+            "zstd" => Ok(CompressionAlgorithm::Zstd),
+            "lz4" => Ok(CompressionAlgorithm::Lz4),
+            "brotli" => Ok(CompressionAlgorithm::Brotli),
+            "snappy" => Ok(CompressionAlgorithm::Snappy),
+            _ => Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("Unsupported compression algorithm: {}", s),
+            )),
+        }
+    }
+}
+
+pub fn compress_block(input: &[u8], algorithm: CompressionAlgorithm) -> Vec<u8> {
+    match algorithm {
+        CompressionAlgorithm::Gzip => {
+            let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+            let _ = encoder.write_all(input);
+            let _ = encoder.flush();
+            encoder.finish().unwrap_or_default()
+        }
+        CompressionAlgorithm::Deflate => {
+            let mut encoder = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
+            let _ = encoder.write_all(input);
+            let _ = encoder.flush();
+            encoder.finish().unwrap_or_default()
+        }
+        CompressionAlgorithm::Zstd => {
+            let mut encoder = zstd::Encoder::new(Vec::new(), 0).expect("zstd encoder");
+            let _ = encoder.write_all(input);
+            encoder.finish().unwrap_or_default()
+        }
+        CompressionAlgorithm::Lz4 => {
+            let mut encoder = lz4::EncoderBuilder::new().build(Vec::new()).expect("lz4 encoder");
+            let _ = encoder.write_all(input);
+            let (out, result) = encoder.finish();
+            result.expect("lz4 finish");
+            out
+        }
+        CompressionAlgorithm::Brotli => {
+            let mut out = Vec::new();
+            brotli::CompressorWriter::new(&mut out, 4096, 5, 22)
+                .write_all(input)
+                .expect("brotli compress");
+            out
+        }
+        CompressionAlgorithm::Snappy => {
+            let mut encoder = snap::write::FrameEncoder::new(Vec::new());
+            let _ = encoder.write_all(input);
+            encoder.into_inner().unwrap_or_default()
+        }
+    }
+}
+
+pub fn decompress_block(compressed: &[u8], algorithm: CompressionAlgorithm) -> io::Result<Vec<u8>> {
+    match algorithm {
+        CompressionAlgorithm::Gzip => {
+            let mut decoder = flate2::read::GzDecoder::new(std::io::Cursor::new(compressed));
+            let mut out = Vec::new();
+            std::io::Read::read_to_end(&mut decoder, &mut out)?;
+            Ok(out)
+        }
+        CompressionAlgorithm::Deflate => {
+            let mut decoder = flate2::read::DeflateDecoder::new(std::io::Cursor::new(compressed));
+            let mut out = Vec::new();
+            std::io::Read::read_to_end(&mut decoder, &mut out)?;
+            Ok(out)
+        }
+        CompressionAlgorithm::Zstd => {
+            let mut decoder = zstd::Decoder::new(std::io::Cursor::new(compressed))?;
+            let mut out = Vec::new();
+            std::io::Read::read_to_end(&mut decoder, &mut out)?;
+            Ok(out)
+        }
+        CompressionAlgorithm::Lz4 => {
+            let mut decoder = lz4::Decoder::new(std::io::Cursor::new(compressed)).expect("lz4 decoder");
+            let mut out = Vec::new();
+            std::io::Read::read_to_end(&mut decoder, &mut out)?;
+            Ok(out)
+        }
+        CompressionAlgorithm::Brotli => {
+            let mut out = Vec::new();
+            let mut decoder = brotli::Decompressor::new(std::io::Cursor::new(compressed), 4096);
+            std::io::Read::read_to_end(&mut decoder, &mut out)?;
+            Ok(out)
+        }
+        CompressionAlgorithm::Snappy => {
+            let mut decoder = snap::read::FrameDecoder::new(std::io::Cursor::new(compressed));
+            let mut out = Vec::new();
+            std::io::Read::read_to_end(&mut decoder, &mut out)?;
+            Ok(out)
+        }
+    }
+}
+
+pub const MIN_COMPRESSIBLE_SIZE: i64 = 4096;
+
+pub fn is_compressible(_headers: &HeaderMap) -> bool {
+    // TODO: Implement this function
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::str::FromStr;
+
+    #[test]
+    fn test_compress_decompress_gzip() {
+        let data = b"hello gzip compress";
+        let compressed = compress_block(data, CompressionAlgorithm::Gzip);
+        let decompressed = decompress_block(&compressed, CompressionAlgorithm::Gzip).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_compress_decompress_deflate() {
+        let data = b"hello deflate compress";
+        let compressed = compress_block(data, CompressionAlgorithm::Deflate);
+        let decompressed = decompress_block(&compressed, CompressionAlgorithm::Deflate).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_compress_decompress_zstd() {
+        let data = b"hello zstd compress";
+        let compressed = compress_block(data, CompressionAlgorithm::Zstd);
+        let decompressed = decompress_block(&compressed, CompressionAlgorithm::Zstd).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_compress_decompress_lz4() {
+        let data = b"hello lz4 compress";
+        let compressed = compress_block(data, CompressionAlgorithm::Lz4);
+        let decompressed = decompress_block(&compressed, CompressionAlgorithm::Lz4).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_compress_decompress_brotli() {
+        let data = b"hello brotli compress";
+        let compressed = compress_block(data, CompressionAlgorithm::Brotli);
+        let decompressed = decompress_block(&compressed, CompressionAlgorithm::Brotli).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_compress_decompress_snappy() {
+        let data = b"hello snappy compress";
+        let compressed = compress_block(data, CompressionAlgorithm::Snappy);
+        let decompressed = decompress_block(&compressed, CompressionAlgorithm::Snappy).unwrap();
+        assert_eq!(decompressed, data);
+    }
+
+    #[test]
+    fn test_from_str() {
+        assert_eq!(CompressionAlgorithm::from_str("gzip").unwrap(), CompressionAlgorithm::Gzip);
+        assert_eq!(CompressionAlgorithm::from_str("deflate").unwrap(), CompressionAlgorithm::Deflate);
+        assert_eq!(CompressionAlgorithm::from_str("zstd").unwrap(), CompressionAlgorithm::Zstd);
+        assert_eq!(CompressionAlgorithm::from_str("lz4").unwrap(), CompressionAlgorithm::Lz4);
+        assert_eq!(CompressionAlgorithm::from_str("brotli").unwrap(), CompressionAlgorithm::Brotli);
+        assert_eq!(CompressionAlgorithm::from_str("snappy").unwrap(), CompressionAlgorithm::Snappy);
+        assert!(CompressionAlgorithm::from_str("unknown").is_err());
+    }
+
+    #[test]
+    fn test_compare_compression_algorithms() {
+        use std::time::Instant;
+        let data = vec![42u8; 1024 * 100]; // 100KB of repetitive data
+
+        // let mut data = vec![0u8; 1024 * 1024];
+        // rand::thread_rng().fill(&mut data[..]);
+
+        let start = Instant::now();
+
+        let mut times = Vec::new();
+        times.push(("original", start.elapsed(), data.len()));
+
+        let start = Instant::now();
+        let gzip = compress_block(&data, CompressionAlgorithm::Gzip);
+        let gzip_time = start.elapsed();
+        times.push(("gzip", gzip_time, gzip.len()));
+
+        let start = Instant::now();
+        let deflate = compress_block(&data, CompressionAlgorithm::Deflate);
+        let deflate_time = start.elapsed();
+        times.push(("deflate", deflate_time, deflate.len()));
+
+        let start = Instant::now();
+        let zstd = compress_block(&data, CompressionAlgorithm::Zstd);
+        let zstd_time = start.elapsed();
+        times.push(("zstd", zstd_time, zstd.len()));
+
+        let start = Instant::now();
+        let lz4 = compress_block(&data, CompressionAlgorithm::Lz4);
+        let lz4_time = start.elapsed();
+        times.push(("lz4", lz4_time, lz4.len()));
+
+        let start = Instant::now();
+        let brotli = compress_block(&data, CompressionAlgorithm::Brotli);
+        let brotli_time = start.elapsed();
+        times.push(("brotli", brotli_time, brotli.len()));
+
+        let start = Instant::now();
+        let snappy = compress_block(&data, CompressionAlgorithm::Snappy);
+        let snappy_time = start.elapsed();
+        times.push(("snappy", snappy_time, snappy.len()));
+
+        println!("Compression results:");
+        for (name, dur, size) in &times {
+            println!("{}: {} bytes, {:?}", name, size, dur);
+        }
+        // All should decompress to the original
+        assert_eq!(decompress_block(&gzip, CompressionAlgorithm::Gzip).unwrap(), data);
+        assert_eq!(decompress_block(&deflate, CompressionAlgorithm::Deflate).unwrap(), data);
+        assert_eq!(decompress_block(&zstd, CompressionAlgorithm::Zstd).unwrap(), data);
+        assert_eq!(decompress_block(&lz4, CompressionAlgorithm::Lz4).unwrap(), data);
+        assert_eq!(decompress_block(&brotli, CompressionAlgorithm::Brotli).unwrap(), data);
+        assert_eq!(decompress_block(&snappy, CompressionAlgorithm::Snappy).unwrap(), data);
+        // All compressed results should not be empty
+        assert!(
+            !gzip.is_empty()
+                && !deflate.is_empty()
+                && !zstd.is_empty()
+                && !lz4.is_empty()
+                && !brotli.is_empty()
+                && !snappy.is_empty()
+        );
+    }
+}

crates/rio/src/compress_reader.rs

@@ -0,0 +1,469 @@
+use crate::compress::{compress_block, decompress_block, CompressionAlgorithm};
+use crate::{EtagResolvable, HashReaderDetector};
+use crate::{HashReaderMut, Reader};
+use pin_project_lite::pin_project;
+use rustfs_utils::{put_uvarint, put_uvarint_len, uvarint};
+use std::io::{self};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, ReadBuf};
+
+pin_project! {
+    #[derive(Debug)]
+    /// A reader wrapper that compresses data on the fly using DEFLATE algorithm.
+    pub struct CompressReader<R> {
+        #[pin]
+        pub inner: R,
+        buffer: Vec<u8>,
+        pos: usize,
+        done: bool,
+        block_size: usize,
+        compression_algorithm: CompressionAlgorithm,
+    }
+}
+
+impl<R> CompressReader<R>
+where
+    R: Reader,
+{
+    pub fn new(inner: R, compression_algorithm: CompressionAlgorithm) -> Self {
+        Self {
+            inner,
+            buffer: Vec::new(),
+            pos: 0,
+            done: false,
+            compression_algorithm,
+            block_size: 1 << 20, // Default 1MB
+        }
+    }
+
+    /// Optional: allow users to customize block_size
+    pub fn with_block_size(inner: R, block_size: usize, compression_algorithm: CompressionAlgorithm) -> Self {
+        Self {
+            inner,
+            buffer: Vec::new(),
+            pos: 0,
+            done: false,
+            compression_algorithm,
+            block_size,
+        }
+    }
+}
+
+impl<R> AsyncRead for CompressReader<R>
+where
+    R: AsyncRead + Unpin + Send + Sync,
+{
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
+        let mut this = self.project();
+        // If buffer has data, serve from buffer first
+        if *this.pos < this.buffer.len() {
+            let to_copy = std::cmp::min(buf.remaining(), this.buffer.len() - *this.pos);
+            buf.put_slice(&this.buffer[*this.pos..*this.pos + to_copy]);
+            *this.pos += to_copy;
+            if *this.pos == this.buffer.len() {
+                this.buffer.clear();
+                *this.pos = 0;
+            }
+            return Poll::Ready(Ok(()));
+        }
+
+        if *this.done {
+            return Poll::Ready(Ok(()));
+        }
+
+        // Read from inner, only read block_size bytes each time
+        let mut temp = vec![0u8; *this.block_size];
+        let mut temp_buf = ReadBuf::new(&mut temp);
+        match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Ok(())) => {
+                let n = temp_buf.filled().len();
+                if n == 0 {
+                    // EOF, write end header
+                    let mut header = [0u8; 8];
+                    header[0] = 0xFF;
+                    *this.buffer = header.to_vec();
+                    *this.pos = 0;
+                    *this.done = true;
+                    let to_copy = std::cmp::min(buf.remaining(), this.buffer.len());
+                    buf.put_slice(&this.buffer[..to_copy]);
+                    *this.pos += to_copy;
+                    Poll::Ready(Ok(()))
+                } else {
+                    let uncompressed_data = &temp_buf.filled()[..n];
+
+                    let crc = crc32fast::hash(uncompressed_data);
+                    let compressed_data = compress_block(uncompressed_data, *this.compression_algorithm);
+
+                    let uncompressed_len = n;
+                    let compressed_len = compressed_data.len();
+                    let int_len = put_uvarint_len(uncompressed_len as u64);
+
+                    let len = compressed_len + int_len + 4; // 4 bytes for CRC32
+
+                    // Header: 8 bytes
+                    // 0: type (0 = compressed, 1 = uncompressed, 0xFF = end)
+                    // 1-3: length (little endian u24)
+                    // 4-7: crc32 (little endian u32)
+                    let mut header = [0u8; 8];
+                    header[0] = 0x00; // 0 = compressed
+                    header[1] = (len & 0xFF) as u8;
+                    header[2] = ((len >> 8) & 0xFF) as u8;
+                    header[3] = ((len >> 16) & 0xFF) as u8;
+                    header[4] = (crc & 0xFF) as u8;
+                    header[5] = ((crc >> 8) & 0xFF) as u8;
+                    header[6] = ((crc >> 16) & 0xFF) as u8;
+                    header[7] = ((crc >> 24) & 0xFF) as u8;
+
+                    // Combine header(4+4) + uncompressed_len + compressed
+                    let mut out = Vec::with_capacity(len + 4);
+                    out.extend_from_slice(&header);
+
+                    let mut uncompressed_len_buf = vec![0u8; int_len];
+                    put_uvarint(&mut uncompressed_len_buf, uncompressed_len as u64);
+                    out.extend_from_slice(&uncompressed_len_buf);
+
+                    out.extend_from_slice(&compressed_data);
+
+                    *this.buffer = out;
+                    *this.pos = 0;
+                    let to_copy = std::cmp::min(buf.remaining(), this.buffer.len());
+                    buf.put_slice(&this.buffer[..to_copy]);
+                    *this.pos += to_copy;
+                    Poll::Ready(Ok(()))
+                }
+            }
+            Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+        }
+    }
+}
+
+impl<R> EtagResolvable for CompressReader<R>
+where
+    R: EtagResolvable,
+{
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        self.inner.try_resolve_etag()
+    }
+}
+
+impl<R> HashReaderDetector for CompressReader<R>
+where
+    R: HashReaderDetector,
+{
+    fn is_hash_reader(&self) -> bool {
+        self.inner.is_hash_reader()
+    }
+
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        self.inner.as_hash_reader_mut()
+    }
+}
+
+pin_project! {
+    /// A reader wrapper that decompresses data on the fly using DEFLATE algorithm.
+    // 1~3 bytes store the length of the compressed data
+    // The first byte stores the type of the compressed data: 00 = compressed, 01 = uncompressed
+    // The first 4 bytes store the CRC32 checksum of the compressed data
+    #[derive(Debug)]
+    pub struct DecompressReader<R> {
+        #[pin]
+        pub inner: R,
+        buffer: Vec<u8>,
+        buffer_pos: usize,
+        finished: bool,
+        // New fields for saving header read progress across polls
+        header_buf: [u8; 8],
+        header_read: usize,
+        header_done: bool,
+        // New fields for saving compressed block read progress across polls
+        compressed_buf: Option<Vec<u8>>,
+        compressed_read: usize,
+        compressed_len: usize,
+        compression_algorithm: CompressionAlgorithm,
+    }
+}
+
+impl<R> DecompressReader<R>
+where
+    R: Reader,
+{
+    pub fn new(inner: R, compression_algorithm: CompressionAlgorithm) -> Self {
+        Self {
+            inner,
+            buffer: Vec::new(),
+            buffer_pos: 0,
+            finished: false,
+            header_buf: [0u8; 8],
+            header_read: 0,
+            header_done: false,
+            compressed_buf: None,
+            compressed_read: 0,
+            compressed_len: 0,
+            compression_algorithm,
+        }
+    }
+}
+
+impl<R> AsyncRead for DecompressReader<R>
+where
+    R: AsyncRead + Unpin + Send + Sync,
+{
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
+        let mut this = self.project();
+        // Serve from buffer if any
+        if *this.buffer_pos < this.buffer.len() {
+            let to_copy = std::cmp::min(buf.remaining(), this.buffer.len() - *this.buffer_pos);
+            buf.put_slice(&this.buffer[*this.buffer_pos..*this.buffer_pos + to_copy]);
+            *this.buffer_pos += to_copy;
+            if *this.buffer_pos == this.buffer.len() {
+                this.buffer.clear();
+                *this.buffer_pos = 0;
+            }
+            return Poll::Ready(Ok(()));
+        }
+
+        if *this.finished {
+            return Poll::Ready(Ok(()));
+        }
+
+        // Read header, support saving progress across polls
+        while !*this.header_done && *this.header_read < 8 {
+            let mut temp = [0u8; 8];
+            let mut temp_buf = ReadBuf::new(&mut temp[0..8 - *this.header_read]);
+            match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Ok(())) => {
+                    let n = temp_buf.filled().len();
+                    if n == 0 {
+                        break;
+                    }
+                    this.header_buf[*this.header_read..*this.header_read + n].copy_from_slice(&temp_buf.filled()[..n]);
+                    *this.header_read += n;
+                }
+                Poll::Ready(Err(e)) => {
+                    return Poll::Ready(Err(e));
+                }
+            }
+            if *this.header_read < 8 {
+                // Header not fully read, return Pending or Ok, wait for next poll
+                return Poll::Pending;
+            }
+        }
+
+        let typ = this.header_buf[0];
+        let len = (this.header_buf[1] as usize) | ((this.header_buf[2] as usize) << 8) | ((this.header_buf[3] as usize) << 16);
+        let crc = (this.header_buf[4] as u32)
+            | ((this.header_buf[5] as u32) << 8)
+            | ((this.header_buf[6] as u32) << 16)
+            | ((this.header_buf[7] as u32) << 24);
+
+        // Header is used up, reset header_read
+        *this.header_read = 0;
+        *this.header_done = true;
+
+        if typ == 0xFF {
+            *this.finished = true;
+            return Poll::Ready(Ok(()));
+        }
+
+        // Save compressed block read progress across polls
+        if this.compressed_buf.is_none() {
+            *this.compressed_len = len - 4;
+            *this.compressed_buf = Some(vec![0u8; *this.compressed_len]);
+            *this.compressed_read = 0;
+        }
+        let compressed_buf = this.compressed_buf.as_mut().unwrap();
+        while *this.compressed_read < *this.compressed_len {
+            let mut temp_buf = ReadBuf::new(&mut compressed_buf[*this.compressed_read..]);
+            match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Ok(())) => {
+                    let n = temp_buf.filled().len();
+                    if n == 0 {
+                        break;
+                    }
+                    *this.compressed_read += n;
+                }
+                Poll::Ready(Err(e)) => {
+                    this.compressed_buf.take();
+                    *this.compressed_read = 0;
+                    *this.compressed_len = 0;
+                    return Poll::Ready(Err(e));
+                }
+            }
+        }
+
+        // After reading all, unpack
+        let (uncompress_len, uvarint) = uvarint(&compressed_buf[0..16]);
+        let compressed_data = &compressed_buf[uvarint as usize..];
+        let decompressed = if typ == 0x00 {
+            match decompress_block(compressed_data, *this.compression_algorithm) {
+                Ok(out) => out,
+                Err(e) => {
+                    this.compressed_buf.take();
+                    *this.compressed_read = 0;
+                    *this.compressed_len = 0;
+                    return Poll::Ready(Err(e));
+                }
+            }
+        } else if typ == 0x01 {
+            compressed_data.to_vec()
+        } else if typ == 0xFF {
+            // Handle end marker
+            this.compressed_buf.take();
+            *this.compressed_read = 0;
+            *this.compressed_len = 0;
+            *this.finished = true;
+            return Poll::Ready(Ok(()));
+        } else {
+            this.compressed_buf.take();
+            *this.compressed_read = 0;
+            *this.compressed_len = 0;
+            return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidData, "Unknown compression type")));
+        };
+        if decompressed.len() != uncompress_len as usize {
+            this.compressed_buf.take();
+            *this.compressed_read = 0;
+            *this.compressed_len = 0;
+            return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidData, "Decompressed length mismatch")));
+        }
+
+        let actual_crc = crc32fast::hash(&decompressed);
+        if actual_crc != crc {
+            this.compressed_buf.take();
+            *this.compressed_read = 0;
+            *this.compressed_len = 0;
+            return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidData, "CRC32 mismatch")));
+        }
+        *this.buffer = decompressed;
+        *this.buffer_pos = 0;
+        // Clear compressed block state for next block
+        this.compressed_buf.take();
+        *this.compressed_read = 0;
+        *this.compressed_len = 0;
+        *this.header_done = false;
+        let to_copy = std::cmp::min(buf.remaining(), this.buffer.len());
+        buf.put_slice(&this.buffer[..to_copy]);
+        *this.buffer_pos += to_copy;
+
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl<R> EtagResolvable for DecompressReader<R>
+where
+    R: EtagResolvable,
+{
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        self.inner.try_resolve_etag()
+    }
+}
+
+impl<R> HashReaderDetector for DecompressReader<R>
+where
+    R: HashReaderDetector,
+{
+    fn is_hash_reader(&self) -> bool {
+        self.inner.is_hash_reader()
+    }
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        self.inner.as_hash_reader_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+    use tokio::io::{AsyncReadExt, BufReader};
+
+    #[tokio::test]
+    async fn test_compress_reader_basic() {
+        let data = b"hello world, hello world, hello world!";
+        let reader = Cursor::new(&data[..]);
+        let mut compress_reader = CompressReader::new(reader, CompressionAlgorithm::Gzip);
+
+        let mut compressed = Vec::new();
+        compress_reader.read_to_end(&mut compressed).await.unwrap();
+
+        // DecompressReader解包
+        let mut decompress_reader = DecompressReader::new(Cursor::new(compressed.clone()), CompressionAlgorithm::Gzip);
+        let mut decompressed = Vec::new();
+        decompress_reader.read_to_end(&mut decompressed).await.unwrap();
+
+        assert_eq!(&decompressed, data);
+    }
+
+    #[tokio::test]
+    async fn test_compress_reader_basic_deflate() {
+        let data = b"hello world, hello world, hello world!";
+        let reader = BufReader::new(&data[..]);
+        let mut compress_reader = CompressReader::new(reader, CompressionAlgorithm::Deflate);
+
+        let mut compressed = Vec::new();
+        compress_reader.read_to_end(&mut compressed).await.unwrap();
+
+        // DecompressReader解包
+        let mut decompress_reader = DecompressReader::new(Cursor::new(compressed.clone()), CompressionAlgorithm::Deflate);
+        let mut decompressed = Vec::new();
+        decompress_reader.read_to_end(&mut decompressed).await.unwrap();
+
+        assert_eq!(&decompressed, data);
+    }
+
+    #[tokio::test]
+    async fn test_compress_reader_empty() {
+        let data = b"";
+        let reader = BufReader::new(&data[..]);
+        let mut compress_reader = CompressReader::new(reader, CompressionAlgorithm::Gzip);
+
+        let mut compressed = Vec::new();
+        compress_reader.read_to_end(&mut compressed).await.unwrap();
+
+        let mut decompress_reader = DecompressReader::new(Cursor::new(compressed.clone()), CompressionAlgorithm::Gzip);
+        let mut decompressed = Vec::new();
+        decompress_reader.read_to_end(&mut decompressed).await.unwrap();
+
+        assert_eq!(&decompressed, data);
+    }
+
+    #[tokio::test]
+    async fn test_compress_reader_large() {
+        use rand::Rng;
+        // Generate 1MB of random bytes
+        let mut data = vec![0u8; 1024 * 1024];
+        rand::thread_rng().fill(&mut data[..]);
+        let reader = Cursor::new(data.clone());
+        let mut compress_reader = CompressReader::new(reader, CompressionAlgorithm::Gzip);
+
+        let mut compressed = Vec::new();
+        compress_reader.read_to_end(&mut compressed).await.unwrap();
+
+        let mut decompress_reader = DecompressReader::new(Cursor::new(compressed.clone()), CompressionAlgorithm::Gzip);
+        let mut decompressed = Vec::new();
+        decompress_reader.read_to_end(&mut decompressed).await.unwrap();
+
+        assert_eq!(&decompressed, &data);
+    }
+
+    #[tokio::test]
+    async fn test_compress_reader_large_deflate() {
+        use rand::Rng;
+        // Generate 1MB of random bytes
+        let mut data = vec![0u8; 1024 * 1024];
+        rand::thread_rng().fill(&mut data[..]);
+        let reader = Cursor::new(data.clone());
+        let mut compress_reader = CompressReader::new(reader, CompressionAlgorithm::Deflate);
+
+        let mut compressed = Vec::new();
+        compress_reader.read_to_end(&mut compressed).await.unwrap();
+
+        let mut decompress_reader = DecompressReader::new(Cursor::new(compressed.clone()), CompressionAlgorithm::Deflate);
+        let mut decompressed = Vec::new();
+        decompress_reader.read_to_end(&mut decompressed).await.unwrap();
+
+        assert_eq!(&decompressed, &data);
+    }
+}

crates/rio/src/encrypt_reader.rs

@@ -0,0 +1,424 @@
+use crate::HashReaderDetector;
+use crate::HashReaderMut;
+use crate::{EtagResolvable, Reader};
+use aes_gcm::aead::Aead;
+use aes_gcm::{Aes256Gcm, KeyInit, Nonce};
+use pin_project_lite::pin_project;
+use rustfs_utils::{put_uvarint, put_uvarint_len};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, ReadBuf};
+
+pin_project! {
+    /// A reader wrapper that encrypts data on the fly using AES-256-GCM.
+    /// This is a demonstration. For production, use a secure and audited crypto library.
+    #[derive(Debug)]
+    pub struct EncryptReader<R> {
+        #[pin]
+        pub inner: R,
+        key: [u8; 32],   // AES-256-GCM key
+        nonce: [u8; 12], // 96-bit nonce for GCM
+        buffer: Vec<u8>,
+        buffer_pos: usize,
+        finished: bool,
+    }
+}
+
+impl<R> EncryptReader<R>
+where
+    R: Reader,
+{
+    pub fn new(inner: R, key: [u8; 32], nonce: [u8; 12]) -> Self {
+        Self {
+            inner,
+            key,
+            nonce,
+            buffer: Vec::new(),
+            buffer_pos: 0,
+            finished: false,
+        }
+    }
+}
+
+impl<R> AsyncRead for EncryptReader<R>
+where
+    R: AsyncRead + Unpin + Send + Sync,
+{
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
+        let mut this = self.project();
+        // Serve from buffer if any
+        if *this.buffer_pos < this.buffer.len() {
+            let to_copy = std::cmp::min(buf.remaining(), this.buffer.len() - *this.buffer_pos);
+            buf.put_slice(&this.buffer[*this.buffer_pos..*this.buffer_pos + to_copy]);
+            *this.buffer_pos += to_copy;
+            if *this.buffer_pos == this.buffer.len() {
+                this.buffer.clear();
+                *this.buffer_pos = 0;
+            }
+            return Poll::Ready(Ok(()));
+        }
+        if *this.finished {
+            return Poll::Ready(Ok(()));
+        }
+        // Read a fixed block size from inner
+        let block_size = 8 * 1024;
+        let mut temp = vec![0u8; block_size];
+        let mut temp_buf = ReadBuf::new(&mut temp);
+        match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Ok(())) => {
+                let n = temp_buf.filled().len();
+                if n == 0 {
+                    // EOF, write end header
+                    let mut header = [0u8; 8];
+                    header[0] = 0xFF; // type: end
+                    *this.buffer = header.to_vec();
+                    *this.buffer_pos = 0;
+                    *this.finished = true;
+                    let to_copy = std::cmp::min(buf.remaining(), this.buffer.len());
+                    buf.put_slice(&this.buffer[..to_copy]);
+                    *this.buffer_pos += to_copy;
+                    Poll::Ready(Ok(()))
+                } else {
+                    // Encrypt the chunk
+                    let cipher = Aes256Gcm::new_from_slice(this.key).expect("key");
+                    let nonce = Nonce::from_slice(this.nonce);
+                    let plaintext = &temp_buf.filled()[..n];
+                    let plaintext_len = plaintext.len();
+                    let crc = crc32fast::hash(plaintext);
+                    let ciphertext = cipher
+                        .encrypt(nonce, plaintext)
+                        .map_err(|e| std::io::Error::other(format!("encrypt error: {e}")))?;
+                    let int_len = put_uvarint_len(plaintext_len as u64);
+                    let clen = int_len + ciphertext.len() + 4;
+                    // Header: 8 bytes
+                    // 0: type (0 = encrypted, 0xFF = end)
+                    // 1-3: length (little endian u24, ciphertext length)
+                    // 4-7: CRC32 of ciphertext (little endian u32)
+                    let mut header = [0u8; 8];
+                    header[0] = 0x00; // 0 = encrypted
+                    header[1] = (clen & 0xFF) as u8;
+                    header[2] = ((clen >> 8) & 0xFF) as u8;
+                    header[3] = ((clen >> 16) & 0xFF) as u8;
+                    header[4] = (crc & 0xFF) as u8;
+                    header[5] = ((crc >> 8) & 0xFF) as u8;
+                    header[6] = ((crc >> 16) & 0xFF) as u8;
+                    header[7] = ((crc >> 24) & 0xFF) as u8;
+                    let mut out = Vec::with_capacity(8 + int_len + ciphertext.len());
+                    out.extend_from_slice(&header);
+                    let mut plaintext_len_buf = vec![0u8; int_len];
+                    put_uvarint(&mut plaintext_len_buf, plaintext_len as u64);
+                    out.extend_from_slice(&plaintext_len_buf);
+                    out.extend_from_slice(&ciphertext);
+                    *this.buffer = out;
+                    *this.buffer_pos = 0;
+                    let to_copy = std::cmp::min(buf.remaining(), this.buffer.len());
+                    buf.put_slice(&this.buffer[..to_copy]);
+                    *this.buffer_pos += to_copy;
+                    Poll::Ready(Ok(()))
+                }
+            }
+            Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+        }
+    }
+}
+
+impl<R> EtagResolvable for EncryptReader<R>
+where
+    R: EtagResolvable,
+{
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        self.inner.try_resolve_etag()
+    }
+}
+
+impl<R> HashReaderDetector for EncryptReader<R>
+where
+    R: EtagResolvable + HashReaderDetector,
+{
+    fn is_hash_reader(&self) -> bool {
+        self.inner.is_hash_reader()
+    }
+
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        self.inner.as_hash_reader_mut()
+    }
+}
+
+pin_project! {
+    /// A reader wrapper that decrypts data on the fly using AES-256-GCM.
+    /// This is a demonstration. For production, use a secure and audited crypto library.
+#[derive(Debug)]
+    pub struct DecryptReader<R> {
+        #[pin]
+        pub inner: R,
+        key: [u8; 32],   // AES-256-GCM key
+        nonce: [u8; 12], // 96-bit nonce for GCM
+        buffer: Vec<u8>,
+        buffer_pos: usize,
+        finished: bool,
+        // For block framing
+        header_buf: [u8; 8],
+        header_read: usize,
+        header_done: bool,
+        ciphertext_buf: Option<Vec<u8>>,
+        ciphertext_read: usize,
+        ciphertext_len: usize,
+    }
+}
+
+impl<R> DecryptReader<R>
+where
+    R: Reader,
+{
+    pub fn new(inner: R, key: [u8; 32], nonce: [u8; 12]) -> Self {
+        Self {
+            inner,
+            key,
+            nonce,
+            buffer: Vec::new(),
+            buffer_pos: 0,
+            finished: false,
+            header_buf: [0u8; 8],
+            header_read: 0,
+            header_done: false,
+            ciphertext_buf: None,
+            ciphertext_read: 0,
+            ciphertext_len: 0,
+        }
+    }
+}
+
+impl<R> AsyncRead for DecryptReader<R>
+where
+    R: AsyncRead + Unpin + Send + Sync,
+{
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
+        let mut this = self.project();
+        // Serve from buffer if any
+        if *this.buffer_pos < this.buffer.len() {
+            let to_copy = std::cmp::min(buf.remaining(), this.buffer.len() - *this.buffer_pos);
+            buf.put_slice(&this.buffer[*this.buffer_pos..*this.buffer_pos + to_copy]);
+            *this.buffer_pos += to_copy;
+            if *this.buffer_pos == this.buffer.len() {
+                this.buffer.clear();
+                *this.buffer_pos = 0;
+            }
+            return Poll::Ready(Ok(()));
+        }
+        if *this.finished {
+            return Poll::Ready(Ok(()));
+        }
+        // Read header (8 bytes), support partial header read
+        while !*this.header_done && *this.header_read < 8 {
+            let mut temp = [0u8; 8];
+            let mut temp_buf = ReadBuf::new(&mut temp[0..8 - *this.header_read]);
+            match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Ok(())) => {
+                    let n = temp_buf.filled().len();
+                    if n == 0 {
+                        break;
+                    }
+                    this.header_buf[*this.header_read..*this.header_read + n].copy_from_slice(&temp_buf.filled()[..n]);
+                    *this.header_read += n;
+                }
+                Poll::Ready(Err(e)) => return Poll::Ready(Err(e)),
+            }
+            if *this.header_read < 8 {
+                return Poll::Pending;
+            }
+        }
+        if !*this.header_done && *this.header_read == 8 {
+            *this.header_done = true;
+        }
+        if !*this.header_done {
+            return Poll::Pending;
+        }
+        let typ = this.header_buf[0];
+        let len = (this.header_buf[1] as usize) | ((this.header_buf[2] as usize) << 8) | ((this.header_buf[3] as usize) << 16);
+        let crc = (this.header_buf[4] as u32)
+            | ((this.header_buf[5] as u32) << 8)
+            | ((this.header_buf[6] as u32) << 16)
+            | ((this.header_buf[7] as u32) << 24);
+        *this.header_read = 0;
+        *this.header_done = false;
+        if typ == 0xFF {
+            *this.finished = true;
+            return Poll::Ready(Ok(()));
+        }
+        // Read ciphertext block (len bytes), support partial read
+        if this.ciphertext_buf.is_none() {
+            *this.ciphertext_len = len - 4; // 4 bytes for CRC32
+            *this.ciphertext_buf = Some(vec![0u8; *this.ciphertext_len]);
+            *this.ciphertext_read = 0;
+        }
+        let ciphertext_buf = this.ciphertext_buf.as_mut().unwrap();
+        while *this.ciphertext_read < *this.ciphertext_len {
+            let mut temp_buf = ReadBuf::new(&mut ciphertext_buf[*this.ciphertext_read..]);
+            match this.inner.as_mut().poll_read(cx, &mut temp_buf) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Ok(())) => {
+                    let n = temp_buf.filled().len();
+                    if n == 0 {
+                        break;
+                    }
+                    *this.ciphertext_read += n;
+                }
+                Poll::Ready(Err(e)) => {
+                    this.ciphertext_buf.take();
+                    *this.ciphertext_read = 0;
+                    *this.ciphertext_len = 0;
+                    return Poll::Ready(Err(e));
+                }
+            }
+        }
+        if *this.ciphertext_read < *this.ciphertext_len {
+            return Poll::Pending;
+        }
+        // Parse uvarint for plaintext length
+        let (plaintext_len, uvarint_len) = rustfs_utils::uvarint(&ciphertext_buf[0..16]);
+        let ciphertext = &ciphertext_buf[uvarint_len as usize..];
+
+        // Decrypt
+        let cipher = Aes256Gcm::new_from_slice(this.key).expect("key");
+        let nonce = Nonce::from_slice(this.nonce);
+        let plaintext = cipher
+            .decrypt(nonce, ciphertext)
+            .map_err(|e| std::io::Error::other(format!("decrypt error: {e}")))?;
+        if plaintext.len() != plaintext_len as usize {
+            this.ciphertext_buf.take();
+            *this.ciphertext_read = 0;
+            *this.ciphertext_len = 0;
+            return Poll::Ready(Err(std::io::Error::other("Plaintext length mismatch")));
+        }
+        // CRC32 check
+        let actual_crc = crc32fast::hash(&plaintext);
+        if actual_crc != crc {
+            this.ciphertext_buf.take();
+            *this.ciphertext_read = 0;
+            *this.ciphertext_len = 0;
+            return Poll::Ready(Err(std::io::Error::other("CRC32 mismatch")));
+        }
+        *this.buffer = plaintext;
+        *this.buffer_pos = 0;
+        // Clear block state for next block
+        this.ciphertext_buf.take();
+        *this.ciphertext_read = 0;
+        *this.ciphertext_len = 0;
+        let to_copy = std::cmp::min(buf.remaining(), this.buffer.len());
+        buf.put_slice(&this.buffer[..to_copy]);
+        *this.buffer_pos += to_copy;
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl<R> EtagResolvable for DecryptReader<R>
+where
+    R: EtagResolvable,
+{
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        self.inner.try_resolve_etag()
+    }
+}
+
+impl<R> HashReaderDetector for DecryptReader<R>
+where
+    R: EtagResolvable + HashReaderDetector,
+{
+    fn is_hash_reader(&self) -> bool {
+        self.inner.is_hash_reader()
+    }
+
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        self.inner.as_hash_reader_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+
+    use super::*;
+    use rand::RngCore;
+    use tokio::io::{AsyncReadExt, BufReader};
+
+    #[tokio::test]
+    async fn test_encrypt_decrypt_reader_aes256gcm() {
+        let data = b"hello sse encrypt";
+        let mut key = [0u8; 32];
+        let mut nonce = [0u8; 12];
+        rand::thread_rng().fill_bytes(&mut key);
+        rand::thread_rng().fill_bytes(&mut nonce);
+
+        let reader = BufReader::new(&data[..]);
+        let encrypt_reader = EncryptReader::new(reader, key, nonce);
+
+        // Encrypt
+        let mut encrypt_reader = encrypt_reader;
+        let mut encrypted = Vec::new();
+        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+
+        // Decrypt using DecryptReader
+        let reader = Cursor::new(encrypted.clone());
+        let decrypt_reader = DecryptReader::new(reader, key, nonce);
+        let mut decrypt_reader = decrypt_reader;
+        let mut decrypted = Vec::new();
+        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+
+        assert_eq!(&decrypted, data);
+    }
+
+    #[tokio::test]
+    async fn test_decrypt_reader_only() {
+        // Encrypt some data first
+        let data = b"test decrypt only";
+        let mut key = [0u8; 32];
+        let mut nonce = [0u8; 12];
+        rand::thread_rng().fill_bytes(&mut key);
+        rand::thread_rng().fill_bytes(&mut nonce);
+
+        // Encrypt
+        let reader = BufReader::new(&data[..]);
+        let encrypt_reader = EncryptReader::new(reader, key, nonce);
+        let mut encrypt_reader = encrypt_reader;
+        let mut encrypted = Vec::new();
+        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+
+        // Now test DecryptReader
+
+        let reader = Cursor::new(encrypted.clone());
+        let decrypt_reader = DecryptReader::new(reader, key, nonce);
+        let mut decrypt_reader = decrypt_reader;
+        let mut decrypted = Vec::new();
+        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+
+        assert_eq!(&decrypted, data);
+    }
+
+    #[tokio::test]
+    async fn test_encrypt_decrypt_reader_large() {
+        use rand::Rng;
+        let size = 1024 * 1024;
+        let mut data = vec![0u8; size];
+        rand::thread_rng().fill(&mut data[..]);
+        let mut key = [0u8; 32];
+        let mut nonce = [0u8; 12];
+        rand::thread_rng().fill_bytes(&mut key);
+        rand::thread_rng().fill_bytes(&mut nonce);
+
+        let reader = std::io::Cursor::new(data.clone());
+        let encrypt_reader = EncryptReader::new(reader, key, nonce);
+        let mut encrypt_reader = encrypt_reader;
+        let mut encrypted = Vec::new();
+        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+
+        let reader = std::io::Cursor::new(encrypted.clone());
+        let decrypt_reader = DecryptReader::new(reader, key, nonce);
+        let mut decrypt_reader = decrypt_reader;
+        let mut decrypted = Vec::new();
+        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+
+        assert_eq!(&decrypted, &data);
+    }
+}

crates/rio/src/etag.rs

@@ -0,0 +1,238 @@
+/*!
+# AsyncRead Wrapper Types with ETag Support
+
+This module demonstrates a pattern for handling wrapped AsyncRead types where:
+- Reader types contain the actual ETag capability
+- Wrapper types need to be recursively unwrapped
+- The system can handle arbitrary nesting like `CompressReader<EncryptReader<EtagReader<R>>>`
+
+## Key Components
+
+### Trait-Based Approach
+The `EtagResolvable` trait provides a clean way to handle recursive unwrapping:
+- Reader types implement it by returning their ETag directly
+- Wrapper types implement it by delegating to their inner type
+
+## Usage Examples
+
+```rust
+// Direct usage with trait-based approach
+let mut reader = CompressReader::new(EtagReader::new(some_async_read, Some("test_etag".to_string())));
+let etag = resolve_etag_generic(&mut reader);
+```
+*/
+
+#[cfg(test)]
+mod tests {
+
+    use crate::compress::CompressionAlgorithm;
+    use crate::resolve_etag_generic;
+    use crate::{CompressReader, EncryptReader, EtagReader, HashReader};
+    use std::io::Cursor;
+    use tokio::io::BufReader;
+
+    #[test]
+    fn test_etag_reader_resolution() {
+        let data = b"test data";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, Some("test_etag".to_string()));
+
+        // Test direct ETag resolution
+        assert_eq!(resolve_etag_generic(&mut etag_reader), Some("test_etag".to_string()));
+    }
+
+    #[test]
+    fn test_hash_reader_resolution() {
+        let data = b"test data";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        let mut hash_reader =
+            HashReader::new(reader, data.len() as i64, data.len() as i64, Some("hash_etag".to_string()), false).unwrap();
+
+        // Test HashReader ETag resolution
+        assert_eq!(resolve_etag_generic(&mut hash_reader), Some("hash_etag".to_string()));
+    }
+
+    #[test]
+    fn test_compress_reader_delegation() {
+        let data = b"test data for compression";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        let etag_reader = EtagReader::new(reader, Some("compress_etag".to_string()));
+        let mut compress_reader = CompressReader::new(etag_reader, CompressionAlgorithm::Gzip);
+
+        // Test that CompressReader delegates to inner EtagReader
+        assert_eq!(resolve_etag_generic(&mut compress_reader), Some("compress_etag".to_string()));
+    }
+
+    #[test]
+    fn test_encrypt_reader_delegation() {
+        let data = b"test data for encryption";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        let etag_reader = EtagReader::new(reader, Some("encrypt_etag".to_string()));
+
+        let key = [0u8; 32];
+        let nonce = [0u8; 12];
+        let mut encrypt_reader = EncryptReader::new(etag_reader, key, nonce);
+
+        // Test that EncryptReader delegates to inner EtagReader
+        assert_eq!(resolve_etag_generic(&mut encrypt_reader), Some("encrypt_etag".to_string()));
+    }
+
+    #[test]
+    fn test_complex_nesting() {
+        let data = b"test data for complex nesting";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        // Create a complex nested structure: CompressReader<EncryptReader<EtagReader<BufReader<Cursor>>>>
+        let etag_reader = EtagReader::new(reader, Some("nested_etag".to_string()));
+        let key = [0u8; 32];
+        let nonce = [0u8; 12];
+        let encrypt_reader = EncryptReader::new(etag_reader, key, nonce);
+        let mut compress_reader = CompressReader::new(encrypt_reader, CompressionAlgorithm::Gzip);
+
+        // Test that nested structure can resolve ETag
+        assert_eq!(resolve_etag_generic(&mut compress_reader), Some("nested_etag".to_string()));
+    }
+
+    #[test]
+    fn test_hash_reader_in_nested_structure() {
+        let data = b"test data for hash reader nesting";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        // Create nested structure: CompressReader<HashReader<BufReader<Cursor>>>
+        let hash_reader =
+            HashReader::new(reader, data.len() as i64, data.len() as i64, Some("hash_nested_etag".to_string()), false).unwrap();
+        let mut compress_reader = CompressReader::new(hash_reader, CompressionAlgorithm::Deflate);
+
+        // Test that nested HashReader can be resolved
+        assert_eq!(resolve_etag_generic(&mut compress_reader), Some("hash_nested_etag".to_string()));
+    }
+
+    #[test]
+    fn test_comprehensive_etag_extraction() {
+        println!("🔍 Testing comprehensive ETag extraction with real reader types...");
+
+        // Test 1: Simple EtagReader
+        let data1 = b"simple test";
+        let reader1 = BufReader::new(Cursor::new(&data1[..]));
+        let reader1 = Box::new(reader1);
+        let mut etag_reader = EtagReader::new(reader1, Some("simple_etag".to_string()));
+        assert_eq!(resolve_etag_generic(&mut etag_reader), Some("simple_etag".to_string()));
+
+        // Test 2: HashReader with ETag
+        let data2 = b"hash test";
+        let reader2 = BufReader::new(Cursor::new(&data2[..]));
+        let reader2 = Box::new(reader2);
+        let mut hash_reader =
+            HashReader::new(reader2, data2.len() as i64, data2.len() as i64, Some("hash_etag".to_string()), false).unwrap();
+        assert_eq!(resolve_etag_generic(&mut hash_reader), Some("hash_etag".to_string()));
+
+        // Test 3: Single wrapper - CompressReader<EtagReader>
+        let data3 = b"compress test";
+        let reader3 = BufReader::new(Cursor::new(&data3[..]));
+        let reader3 = Box::new(reader3);
+        let etag_reader3 = EtagReader::new(reader3, Some("compress_wrapped_etag".to_string()));
+        let mut compress_reader = CompressReader::new(etag_reader3, CompressionAlgorithm::Zstd);
+        assert_eq!(resolve_etag_generic(&mut compress_reader), Some("compress_wrapped_etag".to_string()));
+
+        // Test 4: Double wrapper - CompressReader<EncryptReader<EtagReader>>
+        let data4 = b"double wrap test";
+        let reader4 = BufReader::new(Cursor::new(&data4[..]));
+        let reader4 = Box::new(reader4);
+        let etag_reader4 = EtagReader::new(reader4, Some("double_wrapped_etag".to_string()));
+        let key = [1u8; 32];
+        let nonce = [1u8; 12];
+        let encrypt_reader4 = EncryptReader::new(etag_reader4, key, nonce);
+        let mut compress_reader4 = CompressReader::new(encrypt_reader4, CompressionAlgorithm::Gzip);
+        assert_eq!(resolve_etag_generic(&mut compress_reader4), Some("double_wrapped_etag".to_string()));
+
+        println!("✅ All ETag extraction methods work correctly!");
+        println!("✅ Trait-based approach handles recursive unwrapping!");
+        println!("✅ Complex nesting patterns with real reader types are supported!");
+    }
+
+    #[test]
+    fn test_real_world_scenario() {
+        println!("🔍 Testing real-world ETag extraction scenario with actual reader types...");
+
+        // Simulate a real-world scenario where we have nested AsyncRead wrappers
+        // and need to extract ETag information from deeply nested structures
+
+        let data = b"Real world test data that might be compressed and encrypted";
+        let base_reader = BufReader::new(Cursor::new(&data[..]));
+        let base_reader = Box::new(base_reader);
+        // Create a complex nested structure that might occur in practice:
+        // CompressReader<EncryptReader<HashReader<BufReader<Cursor>>>>
+        let hash_reader = HashReader::new(
+            base_reader,
+            data.len() as i64,
+            data.len() as i64,
+            Some("real_world_etag".to_string()),
+            false,
+        )
+        .unwrap();
+        let key = [42u8; 32];
+        let nonce = [24u8; 12];
+        let encrypt_reader = EncryptReader::new(hash_reader, key, nonce);
+        let mut compress_reader = CompressReader::new(encrypt_reader, CompressionAlgorithm::Deflate);
+
+        // Extract ETag using our generic system
+        let extracted_etag = resolve_etag_generic(&mut compress_reader);
+        println!("📋 Extracted ETag: {:?}", extracted_etag);
+
+        assert_eq!(extracted_etag, Some("real_world_etag".to_string()));
+
+        // Test another complex nesting with EtagReader at the core
+        let data2 = b"Another real world scenario";
+        let base_reader2 = BufReader::new(Cursor::new(&data2[..]));
+        let base_reader2 = Box::new(base_reader2);
+        let etag_reader = EtagReader::new(base_reader2, Some("core_etag".to_string()));
+        let key2 = [99u8; 32];
+        let nonce2 = [88u8; 12];
+        let encrypt_reader2 = EncryptReader::new(etag_reader, key2, nonce2);
+        let mut compress_reader2 = CompressReader::new(encrypt_reader2, CompressionAlgorithm::Zstd);
+
+        let trait_etag = resolve_etag_generic(&mut compress_reader2);
+        println!("📋 Trait-based ETag: {:?}", trait_etag);
+
+        assert_eq!(trait_etag, Some("core_etag".to_string()));
+
+        println!("✅ Real-world scenario test passed!");
+        println!("   - Successfully extracted ETag from nested CompressReader<EncryptReader<HashReader<AsyncRead>>>");
+        println!("   - Successfully extracted ETag from nested CompressReader<EncryptReader<EtagReader<AsyncRead>>>");
+        println!("   - Trait-based approach works with real reader types");
+        println!("   - System handles arbitrary nesting depths with actual implementations");
+    }
+
+    #[test]
+    fn test_no_etag_scenarios() {
+        println!("🔍 Testing scenarios where no ETag is available...");
+
+        // Test with HashReader that has no etag
+        let data = b"no etag test";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        let mut hash_reader_no_etag = HashReader::new(reader, data.len() as i64, data.len() as i64, None, false).unwrap();
+        assert_eq!(resolve_etag_generic(&mut hash_reader_no_etag), None);
+
+        // Test with EtagReader that has None etag
+        let data2 = b"no etag test 2";
+        let reader2 = BufReader::new(Cursor::new(&data2[..]));
+        let reader2 = Box::new(reader2);
+        let mut etag_reader_none = EtagReader::new(reader2, None);
+        assert_eq!(resolve_etag_generic(&mut etag_reader_none), None);
+
+        // Test nested structure with no ETag at the core
+        let data3 = b"nested no etag test";
+        let reader3 = BufReader::new(Cursor::new(&data3[..]));
+        let reader3 = Box::new(reader3);
+        let etag_reader3 = EtagReader::new(reader3, None);
+        let mut compress_reader3 = CompressReader::new(etag_reader3, CompressionAlgorithm::Gzip);
+        assert_eq!(resolve_etag_generic(&mut compress_reader3), None);
+
+        println!("✅ No ETag scenarios handled correctly!");
+    }
+}

crates/rio/src/etag_reader.rs

@@ -0,0 +1,220 @@
+use crate::{EtagResolvable, HashReaderDetector, HashReaderMut, Reader};
+use md5::{Digest, Md5};
+use pin_project_lite::pin_project;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, ReadBuf};
+
+pin_project! {
+    pub struct  EtagReader {
+        #[pin]
+        pub inner: Box<dyn Reader>,
+        pub md5: Md5,
+        pub finished: bool,
+        pub checksum: Option<String>,
+    }
+}
+
+impl EtagReader {
+    pub fn new(inner: Box<dyn Reader>, checksum: Option<String>) -> Self {
+        Self {
+            inner,
+            md5: Md5::new(),
+            finished: false,
+            checksum,
+        }
+    }
+
+    /// Get the final md5 value (etag) as a hex string, only compute once.
+    /// Can be called multiple times, always returns the same result after finished.
+    pub fn get_etag(&mut self) -> String {
+        format!("{:x}", self.md5.clone().finalize())
+    }
+}
+
+impl AsyncRead for EtagReader {
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
+        let mut this = self.project();
+        let orig_filled = buf.filled().len();
+        let poll = this.inner.as_mut().poll_read(cx, buf);
+        if let Poll::Ready(Ok(())) = &poll {
+            let filled = &buf.filled()[orig_filled..];
+            if !filled.is_empty() {
+                this.md5.update(filled);
+            } else {
+                // EOF
+                *this.finished = true;
+                if let Some(checksum) = this.checksum {
+                    let etag = format!("{:x}", this.md5.clone().finalize());
+                    if *checksum != etag {
+                        return Poll::Ready(Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "Checksum mismatch")));
+                    }
+                }
+            }
+        }
+        poll
+    }
+}
+
+impl EtagResolvable for EtagReader {
+    fn is_etag_reader(&self) -> bool {
+        true
+    }
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        // EtagReader provides its own etag, not delegating to inner
+        if let Some(checksum) = &self.checksum {
+            Some(checksum.clone())
+        } else if self.finished {
+            Some(self.get_etag())
+        } else {
+            None
+        }
+    }
+}
+
+impl HashReaderDetector for EtagReader {
+    fn is_hash_reader(&self) -> bool {
+        self.inner.is_hash_reader()
+    }
+
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        self.inner.as_hash_reader_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+    use tokio::io::{AsyncReadExt, BufReader};
+
+    #[tokio::test]
+    async fn test_etag_reader_basic() {
+        let data = b"hello world";
+        let mut hasher = Md5::new();
+        hasher.update(data);
+        let expected = format!("{:x}", hasher.finalize());
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, None);
+
+        let mut buf = Vec::new();
+        let n = etag_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, data.len());
+        assert_eq!(&buf, data);
+
+        let etag = etag_reader.try_resolve_etag();
+        assert_eq!(etag, Some(expected));
+    }
+
+    #[tokio::test]
+    async fn test_etag_reader_empty() {
+        let data = b"";
+        let mut hasher = Md5::new();
+        hasher.update(data);
+        let expected = format!("{:x}", hasher.finalize());
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, None);
+
+        let mut buf = Vec::new();
+        let n = etag_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, 0);
+        assert!(buf.is_empty());
+
+        let etag = etag_reader.try_resolve_etag();
+        assert_eq!(etag, Some(expected));
+    }
+
+    #[tokio::test]
+    async fn test_etag_reader_multiple_get() {
+        let data = b"abc123";
+        let mut hasher = Md5::new();
+        hasher.update(data);
+        let expected = format!("{:x}", hasher.finalize());
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, None);
+
+        let mut buf = Vec::new();
+        let _ = etag_reader.read_to_end(&mut buf).await.unwrap();
+
+        // Call etag multiple times, should always return the same result
+        let etag1 = { etag_reader.try_resolve_etag() };
+        let etag2 = { etag_reader.try_resolve_etag() };
+        assert_eq!(etag1, Some(expected.clone()));
+        assert_eq!(etag2, Some(expected.clone()));
+    }
+
+    #[tokio::test]
+    async fn test_etag_reader_not_finished() {
+        let data = b"abc123";
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, None);
+
+        // Do not read to end, etag should be None
+        let mut buf = [0u8; 2];
+        let _ = etag_reader.read(&mut buf).await.unwrap();
+        assert_eq!(etag_reader.try_resolve_etag(), None);
+    }
+
+    #[tokio::test]
+    async fn test_etag_reader_large_data() {
+        use rand::Rng;
+        // Generate 3MB random data
+        let size = 3 * 1024 * 1024;
+        let mut data = vec![0u8; size];
+        rand::thread_rng().fill(&mut data[..]);
+        let mut hasher = Md5::new();
+        hasher.update(&data);
+
+        let cloned_data = data.clone();
+
+        let expected = format!("{:x}", hasher.finalize());
+
+        let reader = Cursor::new(data.clone());
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, None);
+
+        let mut buf = Vec::new();
+        let n = etag_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, size);
+        assert_eq!(&buf, &cloned_data);
+
+        let etag = etag_reader.try_resolve_etag();
+        assert_eq!(etag, Some(expected));
+    }
+
+    #[tokio::test]
+    async fn test_etag_reader_checksum_match() {
+        let data = b"checksum test data";
+        let mut hasher = Md5::new();
+        hasher.update(data);
+        let expected = format!("{:x}", hasher.finalize());
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, Some(expected.clone()));
+
+        let mut buf = Vec::new();
+        let n = etag_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, data.len());
+        assert_eq!(&buf, data);
+        // 校验通过，etag应等于expected
+        assert_eq!(etag_reader.try_resolve_etag(), Some(expected));
+    }
+
+    #[tokio::test]
+    async fn test_etag_reader_checksum_mismatch() {
+        let data = b"checksum test data";
+        let wrong_checksum = "deadbeefdeadbeefdeadbeefdeadbeef".to_string();
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let mut etag_reader = EtagReader::new(reader, Some(wrong_checksum));
+
+        let mut buf = Vec::new();
+        // 校验失败，应该返回InvalidData错误
+        let err = etag_reader.read_to_end(&mut buf).await.unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
+    }
+}

crates/rio/src/hardlimit_reader.rs

@@ -0,0 +1,134 @@
+use std::io::{Error, Result};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, ReadBuf};
+
+use crate::{EtagResolvable, HashReaderDetector, HashReaderMut, Reader};
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    pub struct HardLimitReader {
+        #[pin]
+        pub inner: Box<dyn Reader>,
+        remaining: i64,
+    }
+}
+
+impl HardLimitReader {
+    pub fn new(inner: Box<dyn Reader>, limit: i64) -> Self {
+        HardLimitReader { inner, remaining: limit }
+    }
+}
+
+impl AsyncRead for HardLimitReader {
+    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<Result<()>> {
+        if self.remaining < 0 {
+            return Poll::Ready(Err(Error::other("input provided more bytes than specified")));
+        }
+        // Save the initial length
+        let before = buf.filled().len();
+
+        // Poll the inner reader
+        let this = self.as_mut().project();
+        let poll = this.inner.poll_read(cx, buf);
+
+        if let Poll::Ready(Ok(())) = &poll {
+            let after = buf.filled().len();
+            let read = (after - before) as i64;
+            self.remaining -= read;
+            if self.remaining < 0 {
+                return Poll::Ready(Err(Error::other("input provided more bytes than specified")));
+            }
+        }
+        poll
+    }
+}
+
+impl EtagResolvable for HardLimitReader {
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        self.inner.try_resolve_etag()
+    }
+}
+
+impl HashReaderDetector for HardLimitReader {
+    fn is_hash_reader(&self) -> bool {
+        self.inner.is_hash_reader()
+    }
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        self.inner.as_hash_reader_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::vec;
+
+    use super::*;
+    use rustfs_utils::read_full;
+    use tokio::io::{AsyncReadExt, BufReader};
+
+    #[tokio::test]
+    async fn test_hardlimit_reader_normal() {
+        let data = b"hello world";
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let hardlimit = HardLimitReader::new(reader, 20);
+        let mut r = hardlimit;
+        let mut buf = Vec::new();
+        let n = r.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, data.len());
+        assert_eq!(&buf, data);
+    }
+
+    #[tokio::test]
+    async fn test_hardlimit_reader_exact_limit() {
+        let data = b"1234567890";
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let hardlimit = HardLimitReader::new(reader, 10);
+        let mut r = hardlimit;
+        let mut buf = Vec::new();
+        let n = r.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, 10);
+        assert_eq!(&buf, data);
+    }
+
+    #[tokio::test]
+    async fn test_hardlimit_reader_exceed_limit() {
+        let data = b"abcdef";
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let hardlimit = HardLimitReader::new(reader, 3);
+        let mut r = hardlimit;
+        let mut buf = vec![0u8; 10];
+        // 读取超限，应该返回错误
+        let err = match read_full(&mut r, &mut buf).await {
+            Ok(n) => {
+                println!("Read {} bytes", n);
+                assert_eq!(n, 3);
+                assert_eq!(&buf[..n], b"abc");
+                None
+            }
+            Err(e) => Some(e),
+        };
+
+        assert!(err.is_some());
+
+        let err = err.unwrap();
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+    }
+
+    #[tokio::test]
+    async fn test_hardlimit_reader_empty() {
+        let data = b"";
+        let reader = BufReader::new(&data[..]);
+        let reader = Box::new(reader);
+        let hardlimit = HardLimitReader::new(reader, 5);
+        let mut r = hardlimit;
+        let mut buf = Vec::new();
+        let n = r.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, 0);
+        assert_eq!(&buf, data);
+    }
+}

crates/rio/src/hash_reader.rs

@@ -0,0 +1,569 @@
+//! HashReader implementation with generic support
+//!
+//! This module provides a generic `HashReader<R>` that can wrap any type implementing
+//! `AsyncRead + Unpin + Send + Sync + 'static + EtagResolvable`.
+//!
+//! ## Migration from the original Reader enum
+//!
+//! The original `HashReader::new` method that worked with the `Reader` enum
+//! has been replaced with a generic approach. To preserve the original logic:
+//!
+//! ### Original logic (before generics):
+//! ```ignore
+//! // Original code would do:
+//! // 1. Check if inner is already a HashReader
+//! // 2. If size > 0, wrap with HardLimitReader  
+//! // 3. If !diskable_md5, wrap with EtagReader
+//! // 4. Create HashReader with the wrapped reader
+//!
+//! let reader = HashReader::new(inner, size, actual_size, etag, diskable_md5)?;
+//! ```
+//!
+//! ### New generic approach:
+//! ```rust
+//! use rustfs_rio::{HashReader, HardLimitReader, EtagReader};
+//! use tokio::io::BufReader;
+//! use std::io::Cursor;
+//!
+//! # tokio_test::block_on(async {
+//! let data = b"hello world";
+//! let reader = BufReader::new(Cursor::new(&data[..]));
+//! let size = data.len() as i64;
+//! let actual_size = size;
+//! let etag = None;
+//! let diskable_md5 = false;
+//!
+//! // Method 1: Simple creation (recommended for most cases)
+//! let hash_reader = HashReader::new(reader, size, actual_size, etag, diskable_md5);
+//!
+//! // Method 2: With manual wrapping to recreate original logic
+//! let reader2 = BufReader::new(Cursor::new(&data[..]));
+//! let wrapped_reader = if size > 0 {
+//!     if !diskable_md5 {
+//!         // Wrap with both HardLimitReader and EtagReader
+//!         let hard_limit = HardLimitReader::new(reader2, size);
+//!         EtagReader::new(hard_limit, etag.clone())
+//!     } else {
+//!         // Only wrap with HardLimitReader
+//!         HardLimitReader::new(reader2, size)
+//!     }
+//! } else if !diskable_md5 {
+//!     // Only wrap with EtagReader
+//!     EtagReader::new(reader2, etag.clone())
+//! } else {
+//!     // No wrapping needed
+//!     reader2
+//! };
+//! let hash_reader2 = HashReader::new(wrapped_reader, size, actual_size, etag, diskable_md5);
+//! # });
+//! ```
+//!
+//! ## HashReader Detection
+//!
+//! The `HashReaderDetector` trait allows detection of existing HashReader instances:
+//!
+//! ```rust
+//! use rustfs_rio::{HashReader, HashReaderDetector};
+//! use tokio::io::BufReader;
+//! use std::io::Cursor;
+//!
+//! # tokio_test::block_on(async {
+//! let data = b"test";
+//! let reader = BufReader::new(Cursor::new(&data[..]));
+//! let hash_reader = HashReader::new(reader, 4, 4, None, false);
+//!
+//! // Check if a type is a HashReader
+//! assert!(hash_reader.is_hash_reader());
+//!
+//! // Use new for compatibility (though it's simpler to use new() directly)
+//! let reader2 = BufReader::new(Cursor::new(&data[..]));
+//! let result = HashReader::new(reader2, 4, 4, None, false);
+//! assert!(result.is_ok());
+//! # });
+//! ```
+
+use pin_project_lite::pin_project;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, ReadBuf};
+
+use crate::{EtagReader, EtagResolvable, HardLimitReader, HashReaderDetector, Reader};
+
+/// Trait for mutable operations on HashReader
+pub trait HashReaderMut {
+    fn bytes_read(&self) -> u64;
+    fn checksum(&self) -> &Option<String>;
+    fn set_checksum(&mut self, checksum: Option<String>);
+    fn size(&self) -> i64;
+    fn set_size(&mut self, size: i64);
+    fn actual_size(&self) -> i64;
+    fn set_actual_size(&mut self, actual_size: i64);
+}
+
+pin_project! {
+
+    pub struct HashReader {
+        #[pin]
+        pub inner: Box<dyn Reader>,
+        pub size: i64,
+        checksum: Option<String>,
+        pub actual_size: i64,
+        pub diskable_md5: bool,
+        bytes_read: u64,
+        // TODO: content_hash
+    }
+
+}
+
+impl HashReader {
+    pub fn new(
+        mut inner: Box<dyn Reader>,
+        size: i64,
+        actual_size: i64,
+        md5: Option<String>,
+        diskable_md5: bool,
+    ) -> std::io::Result<Self> {
+        // Check if it's already a HashReader and update its parameters
+        if let Some(existing_hash_reader) = inner.as_hash_reader_mut() {
+            if existing_hash_reader.bytes_read() > 0 {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    "Cannot create HashReader from an already read HashReader",
+                ));
+            }
+
+            if let Some(checksum) = existing_hash_reader.checksum() {
+                if let Some(ref md5) = md5 {
+                    if checksum != md5 {
+                        return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "HashReader checksum mismatch"));
+                    }
+                }
+            }
+
+            if existing_hash_reader.size() > 0 && size > 0 && existing_hash_reader.size() != size {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    format!("HashReader size mismatch: expected {}, got {}", existing_hash_reader.size(), size),
+                ));
+            }
+
+            existing_hash_reader.set_checksum(md5.clone());
+
+            if existing_hash_reader.size() < 0 && size >= 0 {
+                existing_hash_reader.set_size(size);
+            }
+
+            if existing_hash_reader.actual_size() <= 0 && actual_size >= 0 {
+                existing_hash_reader.set_actual_size(actual_size);
+            }
+
+            return Ok(Self {
+                inner,
+                size,
+                checksum: md5,
+                actual_size,
+                diskable_md5,
+                bytes_read: 0,
+            });
+        }
+
+        if size > 0 {
+            let hr = HardLimitReader::new(inner, size);
+            inner = Box::new(hr);
+            if !diskable_md5 && !inner.is_hash_reader() {
+                let er = EtagReader::new(inner, md5.clone());
+                inner = Box::new(er);
+            }
+        } else if !diskable_md5 {
+            let er = EtagReader::new(inner, md5.clone());
+            inner = Box::new(er);
+        }
+        Ok(Self {
+            inner,
+            size,
+            checksum: md5,
+            actual_size,
+            diskable_md5,
+            bytes_read: 0,
+        })
+    }
+
+    /// Update HashReader parameters
+    pub fn update_params(&mut self, size: i64, actual_size: i64, etag: Option<String>) {
+        if self.size < 0 && size >= 0 {
+            self.size = size;
+        }
+
+        if self.actual_size <= 0 && actual_size > 0 {
+            self.actual_size = actual_size;
+        }
+
+        if etag.is_some() {
+            self.checksum = etag;
+        }
+    }
+
+    pub fn size(&self) -> i64 {
+        self.size
+    }
+    pub fn actual_size(&self) -> i64 {
+        self.actual_size
+    }
+}
+
+impl HashReaderMut for HashReader {
+    fn bytes_read(&self) -> u64 {
+        self.bytes_read
+    }
+
+    fn checksum(&self) -> &Option<String> {
+        &self.checksum
+    }
+
+    fn set_checksum(&mut self, checksum: Option<String>) {
+        self.checksum = checksum;
+    }
+
+    fn size(&self) -> i64 {
+        self.size
+    }
+
+    fn set_size(&mut self, size: i64) {
+        self.size = size;
+    }
+
+    fn actual_size(&self) -> i64 {
+        self.actual_size
+    }
+
+    fn set_actual_size(&mut self, actual_size: i64) {
+        self.actual_size = actual_size;
+    }
+}
+
+impl AsyncRead for HashReader {
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
+        let this = self.project();
+        let poll = this.inner.poll_read(cx, buf);
+        if let Poll::Ready(Ok(())) = &poll {
+            let filled = buf.filled().len();
+            *this.bytes_read += filled as u64;
+
+            if filled == 0 {
+                // EOF
+                // TODO: check content_hash
+            }
+        }
+        poll
+    }
+}
+
+impl EtagResolvable for HashReader {
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        if self.diskable_md5 {
+            return None;
+        }
+        if let Some(etag) = self.inner.try_resolve_etag() {
+            return Some(etag);
+        }
+        // If no etag from inner and we have a stored checksum, return it
+        self.checksum.clone()
+    }
+}
+
+impl HashReaderDetector for HashReader {
+    fn is_hash_reader(&self) -> bool {
+        true
+    }
+
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        Some(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{encrypt_reader, DecryptReader};
+    use std::io::Cursor;
+    use tokio::io::{AsyncReadExt, BufReader};
+
+    #[tokio::test]
+    async fn test_hashreader_wrapping_logic() {
+        let data = b"hello world";
+        let size = data.len() as i64;
+        let actual_size = size;
+        let etag = None;
+
+        // Test 1: Simple creation
+        let reader1 = BufReader::new(Cursor::new(&data[..]));
+        let reader1 = Box::new(reader1);
+        let hash_reader1 = HashReader::new(reader1, size, actual_size, etag.clone(), false).unwrap();
+        assert_eq!(hash_reader1.size(), size);
+        assert_eq!(hash_reader1.actual_size(), actual_size);
+
+        // Test 2: With HardLimitReader wrapping
+        let reader2 = BufReader::new(Cursor::new(&data[..]));
+        let reader2 = Box::new(reader2);
+        let hard_limit = HardLimitReader::new(reader2, size);
+        let hard_limit = Box::new(hard_limit);
+        let hash_reader2 = HashReader::new(hard_limit, size, actual_size, etag.clone(), false).unwrap();
+        assert_eq!(hash_reader2.size(), size);
+        assert_eq!(hash_reader2.actual_size(), actual_size);
+
+        // Test 3: With EtagReader wrapping
+        let reader3 = BufReader::new(Cursor::new(&data[..]));
+        let reader3 = Box::new(reader3);
+        let etag_reader = EtagReader::new(reader3, etag.clone());
+        let etag_reader = Box::new(etag_reader);
+        let hash_reader3 = HashReader::new(etag_reader, size, actual_size, etag.clone(), false).unwrap();
+        assert_eq!(hash_reader3.size(), size);
+        assert_eq!(hash_reader3.actual_size(), actual_size);
+    }
+
+    #[tokio::test]
+    async fn test_hashreader_etag_basic() {
+        let data = b"hello hashreader";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        let mut hash_reader = HashReader::new(reader, data.len() as i64, data.len() as i64, None, false).unwrap();
+        let mut buf = Vec::new();
+        let _ = hash_reader.read_to_end(&mut buf).await.unwrap();
+        // Since we removed EtagReader integration, etag might be None
+        let _etag = hash_reader.try_resolve_etag();
+        // Just check that we can call etag() without error
+        assert_eq!(buf, data);
+    }
+
+    #[tokio::test]
+    async fn test_hashreader_diskable_md5() {
+        let data = b"no etag";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        let mut hash_reader = HashReader::new(reader, data.len() as i64, data.len() as i64, None, true).unwrap();
+        let mut buf = Vec::new();
+        let _ = hash_reader.read_to_end(&mut buf).await.unwrap();
+        // Etag should be None when diskable_md5 is true
+        let etag = hash_reader.try_resolve_etag();
+        assert!(etag.is_none());
+        assert_eq!(buf, data);
+    }
+
+    #[tokio::test]
+    async fn test_hashreader_new_logic() {
+        let data = b"test data";
+        let reader = BufReader::new(Cursor::new(&data[..]));
+        let reader = Box::new(reader);
+        // Create a HashReader first
+        let hash_reader =
+            HashReader::new(reader, data.len() as i64, data.len() as i64, Some("test_etag".to_string()), false).unwrap();
+        let hash_reader = Box::new(hash_reader);
+        // Now try to create another HashReader from the existing one using new
+        let result = HashReader::new(hash_reader, data.len() as i64, data.len() as i64, Some("test_etag".to_string()), false);
+
+        assert!(result.is_ok());
+        let final_reader = result.unwrap();
+        assert_eq!(final_reader.checksum, Some("test_etag".to_string()));
+        assert_eq!(final_reader.size(), data.len() as i64);
+    }
+
+    #[tokio::test]
+    async fn test_for_wrapping_readers() {
+        use crate::compress::CompressionAlgorithm;
+        use crate::{CompressReader, DecompressReader};
+        use md5::{Digest, Md5};
+        use rand::Rng;
+        use rand::RngCore;
+
+        // Generate 1MB random data
+        let size = 1024 * 1024;
+        let mut data = vec![0u8; size];
+        rand::thread_rng().fill(&mut data[..]);
+
+        let mut hasher = Md5::new();
+        hasher.update(&data);
+
+        let expected = format!("{:x}", hasher.finalize());
+
+        println!("expected: {}", expected);
+
+        let reader = Cursor::new(data.clone());
+        let reader = BufReader::new(reader);
+
+        // 启用压缩测试
+        let is_compress = true;
+        let size = data.len() as i64;
+        let actual_size = data.len() as i64;
+
+        let reader = Box::new(reader);
+        // 创建 HashReader
+        let mut hr = HashReader::new(reader, size, actual_size, Some(expected.clone()), false).unwrap();
+
+        // 如果启用压缩，先压缩数据
+        let compressed_data = if is_compress {
+            let mut compressed_buf = Vec::new();
+            let compress_reader = CompressReader::new(hr, CompressionAlgorithm::Gzip);
+            let mut compress_reader = compress_reader;
+            compress_reader.read_to_end(&mut compressed_buf).await.unwrap();
+
+            println!("Original size: {}, Compressed size: {}", data.len(), compressed_buf.len());
+
+            compressed_buf
+        } else {
+            // 如果不压缩，直接读取原始数据
+            let mut buf = Vec::new();
+            hr.read_to_end(&mut buf).await.unwrap();
+            buf
+        };
+
+        let mut key = [0u8; 32];
+        let mut nonce = [0u8; 12];
+        rand::thread_rng().fill_bytes(&mut key);
+        rand::thread_rng().fill_bytes(&mut nonce);
+
+        let is_encrypt = true;
+
+        if is_encrypt {
+            // 加密压缩后的数据
+            let encrypt_reader = encrypt_reader::EncryptReader::new(Cursor::new(compressed_data), key, nonce);
+            let mut encrypted_data = Vec::new();
+            let mut encrypt_reader = encrypt_reader;
+            encrypt_reader.read_to_end(&mut encrypted_data).await.unwrap();
+
+            println!("Encrypted size: {}", encrypted_data.len());
+
+            // 解密数据
+            let decrypt_reader = DecryptReader::new(Cursor::new(encrypted_data), key, nonce);
+            let mut decrypt_reader = decrypt_reader;
+            let mut decrypted_data = Vec::new();
+            decrypt_reader.read_to_end(&mut decrypted_data).await.unwrap();
+
+            if is_compress {
+                // 如果使用了压缩，需要解压缩
+                let decompress_reader = DecompressReader::new(Cursor::new(decrypted_data), CompressionAlgorithm::Gzip);
+                let mut decompress_reader = decompress_reader;
+                let mut final_data = Vec::new();
+                decompress_reader.read_to_end(&mut final_data).await.unwrap();
+
+                println!("Final decompressed size: {}", final_data.len());
+                assert_eq!(final_data.len() as i64, actual_size);
+                assert_eq!(&final_data, &data);
+            } else {
+                // 如果没有压缩，直接比较解密后的数据
+                assert_eq!(decrypted_data.len() as i64, actual_size);
+                assert_eq!(&decrypted_data, &data);
+            }
+            return;
+        }
+
+        // 如果不加密，直接处理压缩/解压缩
+        if is_compress {
+            let decompress_reader = DecompressReader::new(Cursor::new(compressed_data), CompressionAlgorithm::Gzip);
+            let mut decompress_reader = decompress_reader;
+            let mut decompressed = Vec::new();
+            decompress_reader.read_to_end(&mut decompressed).await.unwrap();
+
+            assert_eq!(decompressed.len() as i64, actual_size);
+            assert_eq!(&decompressed, &data);
+        } else {
+            assert_eq!(compressed_data.len() as i64, actual_size);
+            assert_eq!(&compressed_data, &data);
+        }
+
+        // 验证 etag（注意：压缩会改变数据，所以这里的 etag 验证可能需要调整）
+        println!(
+            "Test completed successfully with compression: {}, encryption: {}",
+            is_compress, is_encrypt
+        );
+    }
+
+    #[tokio::test]
+    async fn test_compression_with_compressible_data() {
+        use crate::compress::CompressionAlgorithm;
+        use crate::{CompressReader, DecompressReader};
+
+        // Create highly compressible data (repeated pattern)
+        let pattern = b"Hello, World! This is a test pattern that should compress well. ";
+        let repeat_count = 16384; // 16K repetitions
+        let mut data = Vec::new();
+        for _ in 0..repeat_count {
+            data.extend_from_slice(pattern);
+        }
+
+        println!("Original data size: {} bytes", data.len());
+
+        let reader = BufReader::new(Cursor::new(data.clone()));
+        let reader = Box::new(reader);
+        let hash_reader = HashReader::new(reader, data.len() as i64, data.len() as i64, None, false).unwrap();
+
+        // Test compression
+        let compress_reader = CompressReader::new(hash_reader, CompressionAlgorithm::Gzip);
+        let mut compressed_data = Vec::new();
+        let mut compress_reader = compress_reader;
+        compress_reader.read_to_end(&mut compressed_data).await.unwrap();
+
+        println!("Compressed data size: {} bytes", compressed_data.len());
+        println!("Compression ratio: {:.2}%", (compressed_data.len() as f64 / data.len() as f64) * 100.0);
+
+        // Verify compression actually reduced size for this compressible data
+        assert!(compressed_data.len() < data.len(), "Compression should reduce size for repetitive data");
+
+        // Test decompression
+        let decompress_reader = DecompressReader::new(Cursor::new(compressed_data), CompressionAlgorithm::Gzip);
+        let mut decompressed_data = Vec::new();
+        let mut decompress_reader = decompress_reader;
+        decompress_reader.read_to_end(&mut decompressed_data).await.unwrap();
+
+        // Verify decompressed data matches original
+        assert_eq!(decompressed_data.len(), data.len());
+        assert_eq!(&decompressed_data, &data);
+
+        println!("Compression/decompression test passed successfully!");
+    }
+
+    #[tokio::test]
+    async fn test_compression_algorithms() {
+        use crate::compress::CompressionAlgorithm;
+        use crate::{CompressReader, DecompressReader};
+
+        let data = b"This is test data for compression algorithm testing. ".repeat(1000);
+        println!("Testing with {} bytes of data", data.len());
+
+        let algorithms = vec![
+            CompressionAlgorithm::Gzip,
+            CompressionAlgorithm::Deflate,
+            CompressionAlgorithm::Zstd,
+        ];
+
+        for algorithm in algorithms {
+            println!("\nTesting algorithm: {:?}", algorithm);
+
+            let reader = BufReader::new(Cursor::new(data.clone()));
+            let reader = Box::new(reader);
+            let hash_reader = HashReader::new(reader, data.len() as i64, data.len() as i64, None, false).unwrap();
+
+            // Compress
+            let compress_reader = CompressReader::new(hash_reader, algorithm);
+            let mut compressed_data = Vec::new();
+            let mut compress_reader = compress_reader;
+            compress_reader.read_to_end(&mut compressed_data).await.unwrap();
+
+            println!(
+                "  Compressed size: {} bytes (ratio: {:.2}%)",
+                compressed_data.len(),
+                (compressed_data.len() as f64 / data.len() as f64) * 100.0
+            );
+
+            // Decompress
+            let decompress_reader = DecompressReader::new(Cursor::new(compressed_data), algorithm);
+            let mut decompressed_data = Vec::new();
+            let mut decompress_reader = decompress_reader;
+            decompress_reader.read_to_end(&mut decompressed_data).await.unwrap();
+
+            // Verify
+            assert_eq!(decompressed_data.len(), data.len());
+            assert_eq!(&decompressed_data, &data);
+            println!("  ✓ Algorithm {:?} test passed", algorithm);
+        }
+    }
+}

crates/rio/src/http_reader.rs

@@ -0,0 +1,429 @@
+use bytes::Bytes;
+use futures::{Stream, StreamExt};
+use http::HeaderMap;
+use pin_project_lite::pin_project;
+use reqwest::{Client, Method, RequestBuilder};
+use std::io::{self, Error};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, DuplexStream, ReadBuf};
+use tokio::sync::{mpsc, oneshot};
+
+use crate::{EtagResolvable, HashReaderDetector, HashReaderMut};
+
+static HTTP_DEBUG_LOG: bool = false;
+#[inline(always)]
+fn http_debug_log(args: std::fmt::Arguments) {
+    if HTTP_DEBUG_LOG {
+        println!("{}", args);
+    }
+}
+macro_rules! http_log {
+    ($($arg:tt)*) => {
+        http_debug_log(format_args!($($arg)*));
+    };
+}
+
+pin_project! {
+    pub struct HttpReader {
+        url:String,
+        method: Method,
+        headers: HeaderMap,
+        inner: DuplexStream,
+        err_rx: oneshot::Receiver<std::io::Error>,
+    }
+}
+
+impl HttpReader {
+    pub async fn new(url: String, method: Method, headers: HeaderMap) -> io::Result<Self> {
+        http_log!("[HttpReader::new] url: {url}, method: {method:?}, headers: {headers:?}");
+        Self::with_capacity(url, method, headers, 0).await
+    }
+    /// Create a new HttpReader from a URL. The request is performed immediately.
+    pub async fn with_capacity(url: String, method: Method, headers: HeaderMap, mut read_buf_size: usize) -> io::Result<Self> {
+        http_log!(
+            "[HttpReader::with_capacity] url: {url}, method: {method:?}, headers: {headers:?}, buf_size: {}",
+            read_buf_size
+        );
+        // First, check if the connection is available (HEAD)
+        let client = Client::new();
+        let head_resp = client.head(&url).headers(headers.clone()).send().await;
+        match head_resp {
+            Ok(resp) => {
+                http_log!("[HttpReader::new] HEAD status: {}", resp.status());
+                if !resp.status().is_success() {
+                    return Err(Error::other(format!("HEAD failed: status {}", resp.status())));
+                }
+            }
+            Err(e) => {
+                http_log!("[HttpReader::new] HEAD error: {e}");
+                return Err(Error::other(format!("HEAD request failed: {e}")));
+            }
+        }
+
+        let url_clone = url.clone();
+        let method_clone = method.clone();
+        let headers_clone = headers.clone();
+
+        if read_buf_size == 0 {
+            read_buf_size = 8192; // Default buffer size
+        }
+        let (rd, mut wd) = tokio::io::duplex(read_buf_size);
+        let (err_tx, err_rx) = oneshot::channel::<io::Error>();
+        tokio::spawn(async move {
+            let client = Client::new();
+            let request: RequestBuilder = client.request(method_clone, url_clone).headers(headers_clone);
+
+            let response = request.send().await;
+            match response {
+                Ok(resp) => {
+                    if resp.status().is_success() {
+                        let mut stream = resp.bytes_stream();
+                        while let Some(chunk) = stream.next().await {
+                            match chunk {
+                                Ok(data) => {
+                                    if let Err(e) = wd.write_all(&data).await {
+                                        let _ = err_tx.send(Error::other(format!("HttpReader write error: {}", e)));
+                                        break;
+                                    }
+                                }
+                                Err(e) => {
+                                    let _ = err_tx.send(Error::other(format!("HttpReader stream error: {}", e)));
+                                    break;
+                                }
+                            }
+                        }
+                    } else {
+                        http_log!("[HttpReader::spawn] HTTP request failed with status: {}", resp.status());
+                        let _ = err_tx.send(Error::other(format!(
+                            "HttpReader HTTP request failed with non-200 status {}",
+                            resp.status()
+                        )));
+                    }
+                }
+                Err(e) => {
+                    let _ = err_tx.send(Error::other(format!("HttpReader HTTP request error: {}", e)));
+                }
+            }
+
+            http_log!("[HttpReader::spawn] HTTP request completed, exiting");
+        });
+        Ok(Self {
+            inner: rd,
+            err_rx,
+            url,
+            method,
+            headers,
+        })
+    }
+    pub fn url(&self) -> &str {
+        &self.url
+    }
+    pub fn method(&self) -> &Method {
+        &self.method
+    }
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+}
+
+impl AsyncRead for HttpReader {
+    fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
+        http_log!(
+            "[HttpReader::poll_read] url: {}, method: {:?}, buf.remaining: {}",
+            self.url,
+            self.method,
+            buf.remaining()
+        );
+        // Check for errors from the request
+        match Pin::new(&mut self.err_rx).try_recv() {
+            Ok(e) => return Poll::Ready(Err(e)),
+            Err(oneshot::error::TryRecvError::Empty) => {}
+            Err(oneshot::error::TryRecvError::Closed) => {
+                // return Poll::Ready(Err(Error::new(ErrorKind::Other, "HTTP request closed")));
+            }
+        }
+        // Read from the inner stream
+        Pin::new(&mut self.inner).poll_read(cx, buf)
+    }
+}
+
+impl EtagResolvable for HttpReader {
+    fn is_etag_reader(&self) -> bool {
+        false
+    }
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        None
+    }
+}
+
+impl HashReaderDetector for HttpReader {
+    fn is_hash_reader(&self) -> bool {
+        false
+    }
+
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        None
+    }
+}
+
+struct ReceiverStream {
+    receiver: mpsc::Receiver<Option<Bytes>>,
+}
+
+impl Stream for ReceiverStream {
+    type Item = Result<Bytes, std::io::Error>;
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let poll = Pin::new(&mut self.receiver).poll_recv(cx);
+        match &poll {
+            Poll::Ready(Some(Some(ref bytes))) => {
+                http_log!("[ReceiverStream] poll_next: got {} bytes", bytes.len());
+            }
+            Poll::Ready(Some(None)) => {
+                http_log!("[ReceiverStream] poll_next: sender shutdown");
+            }
+            Poll::Ready(None) => {
+                http_log!("[ReceiverStream] poll_next: channel closed");
+            }
+            Poll::Pending => {
+                // http_log!("[ReceiverStream] poll_next: pending");
+            }
+        }
+        match poll {
+            Poll::Ready(Some(Some(bytes))) => Poll::Ready(Some(Ok(bytes))),
+            Poll::Ready(Some(None)) => Poll::Ready(None), // Sender shutdown
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+pin_project! {
+    pub struct HttpWriter {
+        url:String,
+        method: Method,
+        headers: HeaderMap,
+        err_rx: tokio::sync::oneshot::Receiver<std::io::Error>,
+        sender: tokio::sync::mpsc::Sender<Option<Bytes>>,
+        handle: tokio::task::JoinHandle<std::io::Result<()>>,
+        finish:bool,
+
+    }
+}
+
+impl HttpWriter {
+    /// Create a new HttpWriter for the given URL. The HTTP request is performed in the background.
+    pub async fn new(url: String, method: Method, headers: HeaderMap) -> io::Result<Self> {
+        http_log!("[HttpWriter::new] url: {url}, method: {method:?}, headers: {headers:?}");
+        let url_clone = url.clone();
+        let method_clone = method.clone();
+        let headers_clone = headers.clone();
+
+        // First, try to write empty data to check if writable
+        let client = Client::new();
+        let resp = client.put(&url).headers(headers.clone()).body(Vec::new()).send().await;
+        match resp {
+            Ok(resp) => {
+                http_log!("[HttpWriter::new] empty PUT status: {}", resp.status());
+                if !resp.status().is_success() {
+                    return Err(Error::other(format!("Empty PUT failed: status {}", resp.status())));
+                }
+            }
+            Err(e) => {
+                http_log!("[HttpWriter::new] empty PUT error: {e}");
+                return Err(Error::other(format!("Empty PUT failed: {e}")));
+            }
+        }
+
+        let (sender, receiver) = tokio::sync::mpsc::channel::<Option<Bytes>>(8);
+        let (err_tx, err_rx) = tokio::sync::oneshot::channel::<io::Error>();
+
+        let handle = tokio::spawn(async move {
+            let stream = ReceiverStream { receiver };
+            let body = reqwest::Body::wrap_stream(stream);
+            http_log!(
+                "[HttpWriter::spawn] sending HTTP request: url={url_clone}, method={method_clone:?}, headers={headers_clone:?}"
+            );
+
+            let client = Client::new();
+            let request = client
+                .request(method_clone, url_clone.clone())
+                .headers(headers_clone.clone())
+                .body(body);
+
+            // Hold the request until the shutdown signal is received
+            let response = request.send().await;
+
+            match response {
+                Ok(resp) => {
+                    http_log!("[HttpWriter::spawn] got response: status={}", resp.status());
+                    if !resp.status().is_success() {
+                        let _ = err_tx.send(Error::other(format!(
+                            "HttpWriter HTTP request failed with non-200 status {}",
+                            resp.status()
+                        )));
+                        return Err(Error::other(format!("HTTP request failed with non-200 status {}", resp.status())));
+                    }
+                }
+                Err(e) => {
+                    http_log!("[HttpWriter::spawn] HTTP request error: {e}");
+                    let _ = err_tx.send(Error::other(format!("HTTP request failed: {}", e)));
+                    return Err(Error::other(format!("HTTP request failed: {}", e)));
+                }
+            }
+
+            http_log!("[HttpWriter::spawn] HTTP request completed, exiting");
+            Ok(())
+        });
+
+        http_log!("[HttpWriter::new] connection established successfully");
+        Ok(Self {
+            url,
+            method,
+            headers,
+            err_rx,
+            sender,
+            handle,
+            finish: false,
+        })
+    }
+
+    pub fn url(&self) -> &str {
+        &self.url
+    }
+
+    pub fn method(&self) -> &Method {
+        &self.method
+    }
+
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+}
+
+impl AsyncWrite for HttpWriter {
+    fn poll_write(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
+        http_log!(
+            "[HttpWriter::poll_write] url: {}, method: {:?}, buf.len: {}",
+            self.url,
+            self.method,
+            buf.len()
+        );
+        if let Ok(e) = Pin::new(&mut self.err_rx).try_recv() {
+            return Poll::Ready(Err(e));
+        }
+
+        self.sender
+            .try_send(Some(Bytes::copy_from_slice(buf)))
+            .map_err(|e| Error::other(format!("HttpWriter send error: {}", e)))?;
+
+        Poll::Ready(Ok(buf.len()))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        if !self.finish {
+            http_log!("[HttpWriter::poll_shutdown] url: {}, method: {:?}", self.url, self.method);
+            self.sender
+                .try_send(None)
+                .map_err(|e| Error::other(format!("HttpWriter shutdown error: {}", e)))?;
+            http_log!("[HttpWriter::poll_shutdown] sent shutdown signal to HTTP request");
+
+            self.finish = true;
+        }
+        // Wait for the HTTP request to complete
+        use futures::FutureExt;
+        match Pin::new(&mut self.get_mut().handle).poll_unpin(_cx) {
+            Poll::Ready(Ok(_)) => {
+                http_log!("[HttpWriter::poll_shutdown] HTTP request finished successfully");
+            }
+            Poll::Ready(Err(e)) => {
+                http_log!("[HttpWriter::poll_shutdown] HTTP request failed: {e}");
+                return Poll::Ready(Err(Error::other(format!("HTTP request failed: {}", e))));
+            }
+            Poll::Pending => {
+                return Poll::Pending;
+            }
+        }
+
+        Poll::Ready(Ok(()))
+    }
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+//     use reqwest::Method;
+//     use std::vec;
+//     use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+//     #[tokio::test]
+//     async fn test_http_writer_err() {
+//         // Use a real local server for integration, or mockito for unit test
+//         // Here, we use the Go test server at 127.0.0.1:8081 (scripts/testfile.go)
+//         let url = "http://127.0.0.1:8081/testfile".to_string();
+//         let data = vec![42u8; 8];
+
+//         // Write
+//         // 添加 header X-Deny-Write = 1 模拟不可写入的情况
+//         let mut headers = HeaderMap::new();
+//         headers.insert("X-Deny-Write", "1".parse().unwrap());
+//         // 这里我们使用 PUT 方法
+//         let writer_result = HttpWriter::new(url.clone(), Method::PUT, headers).await;
+//         match writer_result {
+//             Ok(mut writer) => {
+//                 // 如果能创建成功，写入应该报错
+//                 let write_result = writer.write_all(&data).await;
+//                 assert!(write_result.is_err(), "write_all should fail when server denies write");
+//                 if let Err(e) = write_result {
+//                     println!("write_all error: {e}");
+//                 }
+//                 let shutdown_result = writer.shutdown().await;
+//                 if let Err(e) = shutdown_result {
+//                     println!("shutdown error: {e}");
+//                 }
+//             }
+//             Err(e) => {
+//                 // 直接构造失败也可以
+//                 println!("HttpWriter::new error: {e}");
+//                 assert!(
+//                     e.to_string().contains("Empty PUT failed") || e.to_string().contains("Forbidden"),
+//                     "unexpected error: {e}"
+//                 );
+//                 return;
+//             }
+//         }
+//         // Should not reach here
+//         panic!("HttpWriter should not allow writing when server denies write");
+//     }
+
+//     #[tokio::test]
+//     async fn test_http_writer_and_reader_ok() {
+//         // 使用本地 Go 测试服务器
+//         let url = "http://127.0.0.1:8081/testfile".to_string();
+//         let data = vec![99u8; 512 * 1024]; // 512KB of data
+
+//         // Write (不加 X-Deny-Write)
+//         let headers = HeaderMap::new();
+//         let mut writer = HttpWriter::new(url.clone(), Method::PUT, headers).await.unwrap();
+//         writer.write_all(&data).await.unwrap();
+//         writer.shutdown().await.unwrap();
+
+//         http_log!("Wrote {} bytes to {} (ok case)", data.len(), url);
+
+//         // Read back
+//         let mut reader = HttpReader::with_capacity(url.clone(), Method::GET, HeaderMap::new(), 8192)
+//             .await
+//             .unwrap();
+//         let mut buf = Vec::new();
+//         reader.read_to_end(&mut buf).await.unwrap();
+//         assert_eq!(buf, data);
+
+//         // println!("Read {} bytes from {} (ok case)", buf.len(), url);
+//         // tokio::time::sleep(std::time::Duration::from_secs(2)).await; // Wait for server to process
+//         // println!("[test_http_writer_and_reader_ok] completed successfully");
+//     }
+// }

crates/rio/src/lib.rs

@@ -0,0 +1,103 @@
+mod limit_reader;
+use std::io::Cursor;
+
+pub use limit_reader::LimitReader;
+
+mod etag_reader;
+pub use etag_reader::EtagReader;
+
+mod compress_reader;
+pub use compress_reader::{CompressReader, DecompressReader};
+
+mod encrypt_reader;
+pub use encrypt_reader::{DecryptReader, EncryptReader};
+
+mod hardlimit_reader;
+pub use hardlimit_reader::HardLimitReader;
+
+mod hash_reader;
+pub use hash_reader::*;
+
+pub mod compress;
+
+pub mod reader;
+
+mod writer;
+use tokio::io::{AsyncRead, BufReader};
+pub use writer::*;
+
+mod http_reader;
+pub use http_reader::*;
+
+mod bitrot;
+pub use bitrot::*;
+
+mod etag;
+
+pub trait Reader: tokio::io::AsyncRead + Unpin + Send + Sync + EtagResolvable + HashReaderDetector {}
+
+// Trait for types that can be recursively searched for etag capability
+pub trait EtagResolvable {
+    fn is_etag_reader(&self) -> bool {
+        false
+    }
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        None
+    }
+}
+
+// Generic function that can work with any EtagResolvable type
+pub fn resolve_etag_generic<R>(reader: &mut R) -> Option<String>
+where
+    R: EtagResolvable,
+{
+    reader.try_resolve_etag()
+}
+
+impl<T> EtagResolvable for BufReader<T> where T: AsyncRead + Unpin + Send + Sync {}
+
+impl<T> EtagResolvable for Cursor<T> where T: AsRef<[u8]> + Unpin + Send + Sync {}
+
+impl<T> EtagResolvable for Box<T> where T: EtagResolvable {}
+
+/// Trait to detect and manipulate HashReader instances
+pub trait HashReaderDetector {
+    fn is_hash_reader(&self) -> bool {
+        false
+    }
+
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        None
+    }
+}
+
+impl<T> HashReaderDetector for tokio::io::BufReader<T> where T: AsyncRead + Unpin + Send + Sync {}
+
+impl<T> HashReaderDetector for std::io::Cursor<T> where T: AsRef<[u8]> + Unpin + Send + Sync {}
+
+impl HashReaderDetector for Box<dyn AsyncRead + Unpin + Send + Sync> {}
+
+impl<T> HashReaderDetector for Box<T> where T: HashReaderDetector {}
+
+// Blanket implementations for Reader trait
+impl<T> Reader for tokio::io::BufReader<T> where T: AsyncRead + Unpin + Send + Sync {}
+
+impl<T> Reader for std::io::Cursor<T> where T: AsRef<[u8]> + Unpin + Send + Sync {}
+
+impl<T> Reader for Box<T> where T: Reader {}
+
+// Forward declarations for wrapper types that implement all required traits
+impl Reader for crate::HashReader {}
+
+impl Reader for HttpReader {}
+
+impl Reader for crate::HardLimitReader {}
+impl Reader for crate::EtagReader {}
+
+impl<R> Reader for crate::EncryptReader<R> where R: Reader {}
+
+impl<R> Reader for crate::DecryptReader<R> where R: Reader {}
+
+impl<R> Reader for crate::CompressReader<R> where R: Reader {}
+
+impl<R> Reader for crate::DecompressReader<R> where R: Reader {}

crates/rio/src/limit_reader.rs

@@ -0,0 +1,188 @@
+//! LimitReader: a wrapper for AsyncRead that limits the total number of bytes read.
+//!
+//! # Example
+//! ```
+//! use tokio::io::{AsyncReadExt, BufReader};
+//! use rustfs_rio::LimitReader;
+//!
+//! #[tokio::main]
+//! async fn main() {
+//!  let data = b"hello world";
+//!       let reader = BufReader::new(&data[..]);
+//!      let mut limit_reader = LimitReader::new(reader, data.len() as u64);
+//!
+//!      let mut buf = Vec::new();
+//!      let n = limit_reader.read_to_end(&mut buf).await.unwrap();
+//!      assert_eq!(n, data.len());
+//!      assert_eq!(&buf, data);
+//! }
+//! ```
+
+use pin_project_lite::pin_project;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, ReadBuf};
+
+use crate::{EtagResolvable, HashReaderDetector, HashReaderMut, Reader};
+
+pin_project! {
+    #[derive(Debug)]
+    pub struct LimitReader<R> {
+        #[pin]
+        pub inner: R,
+        limit: u64,
+        read: u64,
+    }
+}
+
+/// A wrapper for AsyncRead that limits the total number of bytes read.
+impl<R> LimitReader<R>
+where
+    R: Reader,
+{
+    /// Create a new LimitReader wrapping `inner`, with a total read limit of `limit` bytes.
+    pub fn new(inner: R, limit: u64) -> Self {
+        Self { inner, limit, read: 0 }
+    }
+}
+
+impl<R> AsyncRead for LimitReader<R>
+where
+    R: AsyncRead + Unpin + Send + Sync,
+{
+    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
+        let mut this = self.project();
+        let remaining = this.limit.saturating_sub(*this.read);
+        if remaining == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        let orig_remaining = buf.remaining();
+        let allowed = remaining.min(orig_remaining as u64) as usize;
+        if allowed == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        if allowed == orig_remaining {
+            let before_size = buf.filled().len();
+            let poll = this.inner.as_mut().poll_read(cx, buf);
+            if let Poll::Ready(Ok(())) = &poll {
+                let n = buf.filled().len() - before_size;
+                *this.read += n as u64;
+            }
+            poll
+        } else {
+            let mut temp = vec![0u8; allowed];
+            let mut temp_buf = ReadBuf::new(&mut temp);
+            let poll = this.inner.as_mut().poll_read(cx, &mut temp_buf);
+            if let Poll::Ready(Ok(())) = &poll {
+                let n = temp_buf.filled().len();
+                buf.put_slice(temp_buf.filled());
+                *this.read += n as u64;
+            }
+            poll
+        }
+    }
+}
+
+impl<R> EtagResolvable for LimitReader<R>
+where
+    R: EtagResolvable,
+{
+    fn try_resolve_etag(&mut self) -> Option<String> {
+        self.inner.try_resolve_etag()
+    }
+}
+
+impl<R> HashReaderDetector for LimitReader<R>
+where
+    R: HashReaderDetector,
+{
+    fn is_hash_reader(&self) -> bool {
+        self.inner.is_hash_reader()
+    }
+    fn as_hash_reader_mut(&mut self) -> Option<&mut dyn HashReaderMut> {
+        self.inner.as_hash_reader_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+
+    use super::*;
+    use tokio::io::{AsyncReadExt, BufReader};
+
+    #[tokio::test]
+    async fn test_limit_reader_exact() {
+        let data = b"hello world";
+        let reader = BufReader::new(&data[..]);
+        let mut limit_reader = LimitReader::new(reader, data.len() as u64);
+
+        let mut buf = Vec::new();
+        let n = limit_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, data.len());
+        assert_eq!(&buf, data);
+    }
+
+    #[tokio::test]
+    async fn test_limit_reader_less_than_data() {
+        let data = b"hello world";
+        let reader = BufReader::new(&data[..]);
+        let mut limit_reader = LimitReader::new(reader, 5);
+
+        let mut buf = Vec::new();
+        let n = limit_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, 5);
+        assert_eq!(&buf, b"hello");
+    }
+
+    #[tokio::test]
+    async fn test_limit_reader_zero() {
+        let data = b"hello world";
+        let reader = BufReader::new(&data[..]);
+        let mut limit_reader = LimitReader::new(reader, 0);
+
+        let mut buf = Vec::new();
+        let n = limit_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, 0);
+        assert!(buf.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_limit_reader_multiple_reads() {
+        let data = b"abcdefghij";
+        let reader = BufReader::new(&data[..]);
+        let mut limit_reader = LimitReader::new(reader, 7);
+
+        let mut buf1 = [0u8; 3];
+        let n1 = limit_reader.read(&mut buf1).await.unwrap();
+        assert_eq!(n1, 3);
+        assert_eq!(&buf1, b"abc");
+
+        let mut buf2 = [0u8; 5];
+        let n2 = limit_reader.read(&mut buf2).await.unwrap();
+        assert_eq!(n2, 4);
+        assert_eq!(&buf2[..n2], b"defg");
+
+        let mut buf3 = [0u8; 2];
+        let n3 = limit_reader.read(&mut buf3).await.unwrap();
+        assert_eq!(n3, 0);
+    }
+
+    #[tokio::test]
+    async fn test_limit_reader_large_file() {
+        use rand::Rng;
+        // Generate a 3MB random byte array for testing
+        let size = 3 * 1024 * 1024;
+        let mut data = vec![0u8; size];
+        rand::thread_rng().fill(&mut data[..]);
+        let reader = Cursor::new(data.clone());
+        let mut limit_reader = LimitReader::new(reader, size as u64);
+
+        // Read data into buffer
+        let mut buf = Vec::new();
+        let n = limit_reader.read_to_end(&mut buf).await.unwrap();
+        assert_eq!(n, size);
+        assert_eq!(buf.len(), size);
+        assert_eq!(&buf, &data);
+    }
+}

crates/rio/src/reader.rs

@@ -0,0 +1 @@
+

crates/rio/src/writer.rs

@@ -0,0 +1,168 @@
+use std::io::Cursor;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::AsyncWrite;
+use tokio::io::AsyncWriteExt;
+
+use crate::HttpWriter;
+
+pub enum Writer {
+    Cursor(Cursor<Vec<u8>>),
+    Http(HttpWriter),
+    Other(Box<dyn AsyncWrite + Unpin + Send + Sync>),
+}
+
+impl Writer {
+    /// Create a Writer::Other from any AsyncWrite + Unpin + Send type.
+    pub fn from_tokio_writer<W>(w: W) -> Self
+    where
+        W: AsyncWrite + Unpin + Send + Sync + 'static,
+    {
+        Writer::Other(Box::new(w))
+    }
+
+    pub fn from_cursor(w: Cursor<Vec<u8>>) -> Self {
+        Writer::Cursor(w)
+    }
+
+    pub fn from_http(w: HttpWriter) -> Self {
+        Writer::Http(w)
+    }
+
+    pub fn into_cursor_inner(self) -> Option<Vec<u8>> {
+        match self {
+            Writer::Cursor(w) => Some(w.into_inner()),
+            _ => None,
+        }
+    }
+
+    pub fn as_cursor(&mut self) -> Option<&mut Cursor<Vec<u8>>> {
+        match self {
+            Writer::Cursor(w) => Some(w),
+            _ => None,
+        }
+    }
+    pub fn as_http(&mut self) -> Option<&mut HttpWriter> {
+        match self {
+            Writer::Http(w) => Some(w),
+            _ => None,
+        }
+    }
+
+    pub fn into_http(self) -> Option<HttpWriter> {
+        match self {
+            Writer::Http(w) => Some(w),
+            _ => None,
+        }
+    }
+
+    pub fn into_cursor(self) -> Option<Cursor<Vec<u8>>> {
+        match self {
+            Writer::Cursor(w) => Some(w),
+            _ => None,
+        }
+    }
+}
+
+impl AsyncWrite for Writer {
+    fn poll_write(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> std::task::Poll<std::io::Result<usize>> {
+        match self.get_mut() {
+            Writer::Cursor(w) => Pin::new(w).poll_write(cx, buf),
+            Writer::Http(w) => Pin::new(w).poll_write(cx, buf),
+            Writer::Other(w) => Pin::new(w.as_mut()).poll_write(cx, buf),
+        }
+    }
+
+    fn poll_flush(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<()>> {
+        match self.get_mut() {
+            Writer::Cursor(w) => Pin::new(w).poll_flush(cx),
+            Writer::Http(w) => Pin::new(w).poll_flush(cx),
+            Writer::Other(w) => Pin::new(w.as_mut()).poll_flush(cx),
+        }
+    }
+    fn poll_shutdown(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<()>> {
+        match self.get_mut() {
+            Writer::Cursor(w) => Pin::new(w).poll_shutdown(cx),
+            Writer::Http(w) => Pin::new(w).poll_shutdown(cx),
+            Writer::Other(w) => Pin::new(w.as_mut()).poll_shutdown(cx),
+        }
+    }
+}
+
+/// WriterAll wraps a Writer and ensures each write writes the entire buffer (like write_all).
+pub struct WriterAll<W: AsyncWrite + Unpin> {
+    inner: W,
+}
+
+impl<W: AsyncWrite + Unpin> WriterAll<W> {
+    pub fn new(inner: W) -> Self {
+        Self { inner }
+    }
+
+    /// Write the entire buffer, like write_all.
+    pub async fn write_all(&mut self, mut buf: &[u8]) -> std::io::Result<()> {
+        while !buf.is_empty() {
+            let n = self.inner.write(buf).await?;
+            if n == 0 {
+                return Err(std::io::Error::new(std::io::ErrorKind::WriteZero, "failed to write whole buffer"));
+            }
+            buf = &buf[n..];
+        }
+        Ok(())
+    }
+
+    /// Get a mutable reference to the inner writer.
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.inner
+    }
+}
+
+impl<W: AsyncWrite + Unpin> AsyncWrite for WriterAll<W> {
+    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, mut buf: &[u8]) -> Poll<std::io::Result<usize>> {
+        let mut total_written = 0;
+        while !buf.is_empty() {
+            // Safety: W: Unpin
+            let inner_pin = Pin::new(&mut self.inner);
+            match inner_pin.poll_write(cx, buf) {
+                Poll::Ready(Ok(0)) => {
+                    if total_written == 0 {
+                        return Poll::Ready(Ok(0));
+                    } else {
+                        return Poll::Ready(Ok(total_written));
+                    }
+                }
+                Poll::Ready(Ok(n)) => {
+                    total_written += n;
+                    buf = &buf[n..];
+                }
+                Poll::Ready(Err(e)) => {
+                    if total_written == 0 {
+                        return Poll::Ready(Err(e));
+                    } else {
+                        return Poll::Ready(Ok(total_written));
+                    }
+                }
+                Poll::Pending => {
+                    if total_written == 0 {
+                        return Poll::Pending;
+                    } else {
+                        return Poll::Ready(Ok(total_written));
+                    }
+                }
+            }
+        }
+        Poll::Ready(Ok(total_written))
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}